// $ANTLR 3.1.1 /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g 2011-06-26 00:56:53
// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162
namespace  Pine.SourceParser 
{

using System.Globalization;
using G=System.Collections.Generic;
using T=Pine.SourceParser.Tree;
using Pine.Lexer;


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;

public partial class pinedl : Parser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"FUNCTION", 
		"WORD", 
		"LPAREN", 
		"RPAREN", 
		"COMMA", 
		"VAR", 
		"CONST", 
		"NUMBER", 
		"STRINGCONST", 
		"COLON", 
		"EQUAL", 
		"ELLIPSIS", 
		"SEMICOLON", 
		"LBLOCK", 
		"RBLOCK", 
		"RETURN", 
		"BREAK", 
		"CONTINUE", 
		"IF", 
		"ELSE", 
		"WHILE", 
		"DO", 
		"FOR", 
		"LARRAY", 
		"ARRAYKEYVALUE", 
		"RARRAY", 
		"NUMBERKEYWORD", 
		"CHARCONST", 
		"TRUE", 
		"FALSE", 
		"NULL", 
		"THIS", 
		"CALLEE", 
		"DOT", 
		"INCREMENT", 
		"DECREMENT", 
		"PLUS", 
		"MINUS", 
		"BITNOT", 
		"LOGNOT", 
		"MULT", 
		"LESS", 
		"LESSOREQUAL", 
		"GREATER", 
		"GREATEROREQUAL", 
		"EQUALS", 
		"NOTEQUAL", 
		"LOGICALAND", 
		"LOGICALOR"
    };

    public const int FUNCTION = 4;
    public const int BITNOT = 42;
    public const int RARRAY = 29;
    public const int WHILE = 24;
    public const int CONST = 10;
    public const int DO = 25;
    public const int FOR = 26;
    public const int EQUALS = 49;
    public const int EOF = -1;
    public const int BREAK = 20;
    public const int LPAREN = 6;
    public const int IF = 22;
    public const int LOGICALAND = 51;
    public const int NOTEQUAL = 50;
    public const int WORD = 5;
    public const int RPAREN = 7;
    public const int GREATER = 47;
    public const int LESSOREQUAL = 46;
    public const int CONTINUE = 21;
    public const int COMMA = 8;
    public const int GREATEROREQUAL = 48;
    public const int EQUAL = 14;
    public const int LOGICALOR = 52;
    public const int LESS = 45;
    public const int RETURN = 19;
    public const int THIS = 35;
    public const int STRINGCONST = 12;
    public const int PLUS = 40;
    public const int VAR = 9;
    public const int DOT = 37;
    public const int NUMBERKEYWORD = 30;
    public const int LARRAY = 27;
    public const int NULL = 34;
    public const int ELSE = 23;
    public const int NUMBER = 11;
    public const int ELLIPSIS = 15;
    public const int SEMICOLON = 16;
    public const int MULT = 44;
    public const int LBLOCK = 17;
    public const int MINUS = 41;
    public const int TRUE = 32;
    public const int DECREMENT = 39;
    public const int COLON = 13;
    public const int RBLOCK = 18;
    public const int INCREMENT = 38;
    public const int CALLEE = 36;
    public const int FALSE = 33;
    public const int CHARCONST = 31;
    public const int ARRAYKEYVALUE = 28;
    public const int LOGNOT = 43;

    // delegates
    // delegators



        public pinedl(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public pinedl(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }
        

    override public string[] TokenNames {
		get { return pinedl.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "/home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g"; }
    }



    // $ANTLR start "document"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:39:1: document returns [T.Document doc ] : (f= docfunctiondecl )* EOF ;
    public T.Document document() // throws RecognitionException [1]
    {   
        T.Document doc = default(T.Document);

        pinedl.docfunctiondecl_return f = default(pinedl.docfunctiondecl_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:40:2: ( (f= docfunctiondecl )* EOF )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:40:4: (f= docfunctiondecl )* EOF
            {
            	if ( state.backtracking == 0 ) 
            	{
            	   doc =  new T.Document(); 
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:41:2: (f= docfunctiondecl )*
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);

            	    if ( (LA1_0 == FUNCTION) )
            	    {
            	        alt1 = 1;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:41:3: f= docfunctiondecl
            			    {
            			    	PushFollow(FOLLOW_docfunctiondecl_in_document77);
            			    	f = docfunctiondecl();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return doc;
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  doc.varDecls.Add(((f != null) ? f.decl : default(T.SimpleVariableDeclaration)));
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop1;
            	    }
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements

            	Match(input,EOF,FOLLOW_EOF_in_document83); if (state.failed) return doc;

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return doc;
    }
    // $ANTLR end "document"

    public class docfunctiondecl_return : ParserRuleReturnScope
    {
        public T.SimpleVariableDeclaration decl;
        public T.Function func;
    };

    // $ANTLR start "docfunctiondecl"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:43:1: docfunctiondecl returns [T.SimpleVariableDeclaration decl, T.Function func] : f= FUNCTION name= WORD LPAREN alist= arglist RPAREN s= statement ;
    public pinedl.docfunctiondecl_return docfunctiondecl() // throws RecognitionException [1]
    {   
        pinedl.docfunctiondecl_return retval = new pinedl.docfunctiondecl_return();
        retval.Start = input.LT(1);

        IToken f = null;
        IToken name = null;
        pinedl.arglist_return alist = default(pinedl.arglist_return);

        T.Statement s = default(T.Statement);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:44:2: (f= FUNCTION name= WORD LPAREN alist= arglist RPAREN s= statement )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:44:4: f= FUNCTION name= WORD LPAREN alist= arglist RPAREN s= statement
            {
            	if ( state.backtracking == 0 ) 
            	{

            	  	retval.decl =  new T.SimpleVariableDeclaration(); retval.decl.IsConst = true;
            	  	retval.func =  new T.Function();
            	  	
            	}
            	f=(IToken)Match(input,FUNCTION,FOLLOW_FUNCTION_in_docfunctiondecl101); if (state.failed) return retval;
            	name=(IToken)Match(input,WORD,FOLLOW_WORD_in_docfunctiondecl105); if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{

            	  	 retval.decl.Value = retval.func; retval.func.metadata["vardecl-fname"] = retval.decl.Name = name.Text;
            	  	
            	}
            	Match(input,LPAREN,FOLLOW_LPAREN_in_docfunctiondecl110); if (state.failed) return retval;
            	PushFollow(FOLLOW_arglist_in_docfunctiondecl114);
            	alist = arglist();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	   retval.func.arguments = ((alist != null) ? alist.args : default(G.IList<T.FunctionArgument>)); 
            	}
            	Match(input,RPAREN,FOLLOW_RPAREN_in_docfunctiondecl118); if (state.failed) return retval;
            	PushFollow(FOLLOW_statement_in_docfunctiondecl123);
            	s = statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{

            	  		retval.func.stmt = s;
            	  		retval.decl.StartToken = retval.func.StartToken =f.ToSource();
            	  		retval.decl.EndToken = retval.func.EndToken = input.LT(-1).ToSource(); 
            	  	
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "docfunctiondecl"

    public class arglist_return : ParserRuleReturnScope
    {
        public G.IList<T.FunctionArgument> args;
        public bool isConst;
        public T.Expression e1;
        public object prevkey;
        public object ckey;
    };

    // $ANTLR start "arglist"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:59:1: arglist returns [G.IList<T.FunctionArgument> args, bool isConst, T.Expression e1, object prevkey, object ckey] : ( (arg1= ordinary_argument[$isConst, $prevkey] ( COMMA o= ordinary_argument[$isConst, $prevkey] )* ( COMMA v= vararg_argument[$isConst] )? ) | (a1= vararg_argument[$isConst] ) )? ;
    public pinedl.arglist_return arglist() // throws RecognitionException [1]
    {   
        pinedl.arglist_return retval = new pinedl.arglist_return();
        retval.Start = input.LT(1);

        pinedl.ordinary_argument_return arg1 = default(pinedl.ordinary_argument_return);

        pinedl.ordinary_argument_return o = default(pinedl.ordinary_argument_return);

        T.FunctionArgument v = default(T.FunctionArgument);

        T.FunctionArgument a1 = default(T.FunctionArgument);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:60:2: ( ( (arg1= ordinary_argument[$isConst, $prevkey] ( COMMA o= ordinary_argument[$isConst, $prevkey] )* ( COMMA v= vararg_argument[$isConst] )? ) | (a1= vararg_argument[$isConst] ) )? )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:61:2: ( (arg1= ordinary_argument[$isConst, $prevkey] ( COMMA o= ordinary_argument[$isConst, $prevkey] )* ( COMMA v= vararg_argument[$isConst] )? ) | (a1= vararg_argument[$isConst] ) )?
            {
            	if ( state.backtracking == 0 ) 
            	{

            	  		retval.args =  new G.List<T.FunctionArgument>();
            	  		retval.isConst =  true;
            	  		retval.e1 =  null;
            	  		retval.prevkey =  -1.0;
            	  		retval.ckey =  null;
            	  	
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:68:3: ( (arg1= ordinary_argument[$isConst, $prevkey] ( COMMA o= ordinary_argument[$isConst, $prevkey] )* ( COMMA v= vararg_argument[$isConst] )? ) | (a1= vararg_argument[$isConst] ) )?
            	int alt4 = 3;
            	switch ( input.LA(1) ) 
            	{
            	    case VAR:
            	    	{
            	        int LA4_1 = input.LA(2);

            	        if ( (LA4_1 == WORD) )
            	        {
            	            int LA4_4 = input.LA(3);

            	            if ( ((LA4_4 >= RPAREN && LA4_4 <= COMMA) || (LA4_4 >= COLON && LA4_4 <= EQUAL)) )
            	            {
            	                alt4 = 1;
            	            }
            	            else if ( (LA4_4 == ELLIPSIS) )
            	            {
            	                alt4 = 2;
            	            }
            	        }
            	        else if ( ((LA4_1 >= NUMBER && LA4_1 <= STRINGCONST)) )
            	        {
            	            alt4 = 1;
            	        }
            	        }
            	        break;
            	    case CONST:
            	    	{
            	        int LA4_2 = input.LA(2);

            	        if ( ((LA4_2 >= NUMBER && LA4_2 <= STRINGCONST)) )
            	        {
            	            alt4 = 1;
            	        }
            	        else if ( (LA4_2 == WORD) )
            	        {
            	            int LA4_4 = input.LA(3);

            	            if ( ((LA4_4 >= RPAREN && LA4_4 <= COMMA) || (LA4_4 >= COLON && LA4_4 <= EQUAL)) )
            	            {
            	                alt4 = 1;
            	            }
            	            else if ( (LA4_4 == ELLIPSIS) )
            	            {
            	                alt4 = 2;
            	            }
            	        }
            	        }
            	        break;
            	    case NUMBER:
            	    case STRINGCONST:
            	    	{
            	        alt4 = 1;
            	        }
            	        break;
            	    case WORD:
            	    	{
            	        int LA4_4 = input.LA(2);

            	        if ( ((LA4_4 >= RPAREN && LA4_4 <= COMMA) || (LA4_4 >= COLON && LA4_4 <= EQUAL)) )
            	        {
            	            alt4 = 1;
            	        }
            	        else if ( (LA4_4 == ELLIPSIS) )
            	        {
            	            alt4 = 2;
            	        }
            	        }
            	        break;
            	}

            	switch (alt4) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:69:4: (arg1= ordinary_argument[$isConst, $prevkey] ( COMMA o= ordinary_argument[$isConst, $prevkey] )* ( COMMA v= vararg_argument[$isConst] )? )
            	        {
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:69:4: (arg1= ordinary_argument[$isConst, $prevkey] ( COMMA o= ordinary_argument[$isConst, $prevkey] )* ( COMMA v= vararg_argument[$isConst] )? )
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:70:5: arg1= ordinary_argument[$isConst, $prevkey] ( COMMA o= ordinary_argument[$isConst, $prevkey] )* ( COMMA v= vararg_argument[$isConst] )?
            	        	{
            	        		PushFollow(FOLLOW_ordinary_argument_in_arglist157);
            	        		arg1 = ordinary_argument(retval.isConst, retval.prevkey);
            	        		state.followingStackPointer--;
            	        		if (state.failed) return retval;
            	        		if ( state.backtracking == 0 ) 
            	        		{
            	        		  retval.args.Add(((arg1 != null) ? arg1.arg : default(T.FunctionArgument))); retval.isConst =  ((arg1 != null) ? arg1.arg : default(T.FunctionArgument)).isConst; retval.prevkey =  ((arg1 != null) ? arg1.arg : default(T.FunctionArgument)).key; 
            	        		}
            	        		// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:71:5: ( COMMA o= ordinary_argument[$isConst, $prevkey] )*
            	        		do 
            	        		{
            	        		    int alt2 = 2;
            	        		    int LA2_0 = input.LA(1);

            	        		    if ( (LA2_0 == COMMA) )
            	        		    {
            	        		        switch ( input.LA(2) ) 
            	        		        {
            	        		        case VAR:
            	        		        	{
            	        		            int LA2_3 = input.LA(3);

            	        		            if ( ((LA2_3 >= NUMBER && LA2_3 <= STRINGCONST)) )
            	        		            {
            	        		                alt2 = 1;
            	        		            }
            	        		            else if ( (LA2_3 == WORD) )
            	        		            {
            	        		                int LA2_5 = input.LA(4);

            	        		                if ( ((LA2_5 >= RPAREN && LA2_5 <= COMMA) || (LA2_5 >= COLON && LA2_5 <= EQUAL)) )
            	        		                {
            	        		                    alt2 = 1;
            	        		                }


            	        		            }


            	        		            }
            	        		            break;
            	        		        case CONST:
            	        		        	{
            	        		            int LA2_4 = input.LA(3);

            	        		            if ( (LA2_4 == WORD) )
            	        		            {
            	        		                int LA2_5 = input.LA(4);

            	        		                if ( ((LA2_5 >= RPAREN && LA2_5 <= COMMA) || (LA2_5 >= COLON && LA2_5 <= EQUAL)) )
            	        		                {
            	        		                    alt2 = 1;
            	        		                }


            	        		            }
            	        		            else if ( ((LA2_4 >= NUMBER && LA2_4 <= STRINGCONST)) )
            	        		            {
            	        		                alt2 = 1;
            	        		            }


            	        		            }
            	        		            break;
            	        		        case WORD:
            	        		        	{
            	        		            int LA2_5 = input.LA(3);

            	        		            if ( ((LA2_5 >= RPAREN && LA2_5 <= COMMA) || (LA2_5 >= COLON && LA2_5 <= EQUAL)) )
            	        		            {
            	        		                alt2 = 1;
            	        		            }


            	        		            }
            	        		            break;
            	        		        case NUMBER:
            	        		        case STRINGCONST:
            	        		        	{
            	        		            alt2 = 1;
            	        		            }
            	        		            break;

            	        		        }

            	        		    }


            	        		    switch (alt2) 
            	        			{
            	        				case 1 :
            	        				    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:71:6: COMMA o= ordinary_argument[$isConst, $prevkey]
            	        				    {
            	        				    	Match(input,COMMA,FOLLOW_COMMA_in_arglist167); if (state.failed) return retval;
            	        				    	PushFollow(FOLLOW_ordinary_argument_in_arglist176);
            	        				    	o = ordinary_argument(retval.isConst, retval.prevkey);
            	        				    	state.followingStackPointer--;
            	        				    	if (state.failed) return retval;
            	        				    	if ( state.backtracking == 0 ) 
            	        				    	{
            	        				    	  retval.args.Add(((o != null) ? o.arg : default(T.FunctionArgument))); retval.isConst =  ((o != null) ? o.arg : default(T.FunctionArgument)).isConst; retval.prevkey =  ((o != null) ? o.arg : default(T.FunctionArgument)).key; 
            	        				    	}

            	        				    }
            	        				    break;

            	        				default:
            	        				    goto loop2;
            	        		    }
            	        		} while (true);

            	        		loop2:
            	        			;	// Stops C# compiler whining that label 'loop2' has no statements

            	        		// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:74:5: ( COMMA v= vararg_argument[$isConst] )?
            	        		int alt3 = 2;
            	        		int LA3_0 = input.LA(1);

            	        		if ( (LA3_0 == COMMA) )
            	        		{
            	        		    alt3 = 1;
            	        		}
            	        		switch (alt3) 
            	        		{
            	        		    case 1 :
            	        		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:74:6: COMMA v= vararg_argument[$isConst]
            	        		        {
            	        		        	Match(input,COMMA,FOLLOW_COMMA_in_arglist193); if (state.failed) return retval;
            	        		        	PushFollow(FOLLOW_vararg_argument_in_arglist197);
            	        		        	v = vararg_argument(retval.isConst);
            	        		        	state.followingStackPointer--;
            	        		        	if (state.failed) return retval;
            	        		        	if ( state.backtracking == 0 ) 
            	        		        	{
            	        		        	  retval.args.Add(v); retval.isConst =  v.isConst; retval.prevkey =  v.key; 
            	        		        	}

            	        		        }
            	        		        break;

            	        		}


            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:77:4: (a1= vararg_argument[$isConst] )
            	        {
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:77:4: (a1= vararg_argument[$isConst] )
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:77:5: a1= vararg_argument[$isConst]
            	        	{
            	        		PushFollow(FOLLOW_vararg_argument_in_arglist220);
            	        		a1 = vararg_argument(retval.isConst);
            	        		state.followingStackPointer--;
            	        		if (state.failed) return retval;
            	        		if ( state.backtracking == 0 ) 
            	        		{
            	        		  retval.args.Add(a1);
            	        		}

            	        	}


            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "arglist"

    public class ordinary_argument_return : ParserRuleReturnScope
    {
        public T.FunctionArgument arg;
        public object ckey;
    };

    // $ANTLR start "ordinary_argument"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:80:1: ordinary_argument[bool isConst, object prevkey] returns [T.FunctionArgument arg, object ckey] : ( VAR | CONST )? ( (n= NUMBER | w= WORD | str= STRINGCONST ) COLON )? name= WORD ( EQUAL exp= expression )? ;
    public pinedl.ordinary_argument_return ordinary_argument(bool isConst, object prevkey) // throws RecognitionException [1]
    {   
        pinedl.ordinary_argument_return retval = new pinedl.ordinary_argument_return();
        retval.Start = input.LT(1);

        IToken n = null;
        IToken w = null;
        IToken str = null;
        IToken name = null;
        T.Expression exp = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:81:2: ( ( VAR | CONST )? ( (n= NUMBER | w= WORD | str= STRINGCONST ) COLON )? name= WORD ( EQUAL exp= expression )? )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:82:2: ( VAR | CONST )? ( (n= NUMBER | w= WORD | str= STRINGCONST ) COLON )? name= WORD ( EQUAL exp= expression )?
            {
            	if ( state.backtracking == 0 ) 
            	{

            	  		retval.ckey =  null;
            	  		retval.arg =  new T.FunctionArgument();
            	  		retval.arg.StartToken = input.LT(1).ToSource();
            	  	
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:87:2: ( VAR | CONST )?
            	int alt5 = 3;
            	int LA5_0 = input.LA(1);

            	if ( (LA5_0 == VAR) )
            	{
            	    alt5 = 1;
            	}
            	else if ( (LA5_0 == CONST) )
            	{
            	    alt5 = 2;
            	}
            	switch (alt5) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:87:3: VAR
            	        {
            	        	Match(input,VAR,FOLLOW_VAR_in_ordinary_argument249); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  isConst =  false;
            	        	}

            	        }
            	        break;
            	    case 2 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:87:29: CONST
            	        {
            	        	Match(input,CONST,FOLLOW_CONST_in_ordinary_argument255); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  isConst =  true;
            	        	}

            	        }
            	        break;

            	}

            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:88:2: ( (n= NUMBER | w= WORD | str= STRINGCONST ) COLON )?
            	int alt7 = 2;
            	int LA7_0 = input.LA(1);

            	if ( ((LA7_0 >= NUMBER && LA7_0 <= STRINGCONST)) )
            	{
            	    alt7 = 1;
            	}
            	else if ( (LA7_0 == WORD) )
            	{
            	    int LA7_2 = input.LA(2);

            	    if ( (LA7_2 == COLON) )
            	    {
            	        alt7 = 1;
            	    }
            	}
            	switch (alt7) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:88:3: (n= NUMBER | w= WORD | str= STRINGCONST ) COLON
            	        {
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:88:3: (n= NUMBER | w= WORD | str= STRINGCONST )
            	        	int alt6 = 3;
            	        	switch ( input.LA(1) ) 
            	        	{
            	        	case NUMBER:
            	        		{
            	        	    alt6 = 1;
            	        	    }
            	        	    break;
            	        	case WORD:
            	        		{
            	        	    alt6 = 2;
            	        	    }
            	        	    break;
            	        	case STRINGCONST:
            	        		{
            	        	    alt6 = 3;
            	        	    }
            	        	    break;
            	        		default:
            	        		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        		    NoViableAltException nvae_d6s0 =
            	        		        new NoViableAltException("", 6, 0, input);

            	        		    throw nvae_d6s0;
            	        	}

            	        	switch (alt6) 
            	        	{
            	        	    case 1 :
            	        	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:88:4: n= NUMBER
            	        	        {
            	        	        	n=(IToken)Match(input,NUMBER,FOLLOW_NUMBER_in_ordinary_argument266); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) 
            	        	        	{
            	        	        	  retval.ckey =  Double.Parse(n.Text, CultureInfo.InvariantCulture); 
            	        	        	}

            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:89:5: w= WORD
            	        	        {
            	        	        	w=(IToken)Match(input,WORD,FOLLOW_WORD_in_ordinary_argument276); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) 
            	        	        	{
            	        	        	  retval.ckey =  w.Text; 
            	        	        	}

            	        	        }
            	        	        break;
            	        	    case 3 :
            	        	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:90:5: str= STRINGCONST
            	        	        {
            	        	        	str=(IToken)Match(input,STRINGCONST,FOLLOW_STRINGCONST_in_ordinary_argument286); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) 
            	        	        	{
            	        	        	  retval.ckey =  str.Text; 
            	        	        	}

            	        	        }
            	        	        break;

            	        	}

            	        	Match(input,COLON,FOLLOW_COLON_in_ordinary_argument292); if (state.failed) return retval;

            	        }
            	        break;

            	}

            	if ( state.backtracking == 0 ) 
            	{

            	  		if (retval.ckey == null) {
            	  			if (prevkey is string) throw new Exception("Invalid argument list: Expected argument key");
            	  			retval.ckey =  ((double) prevkey)+1;
            	  		}
            	  		retval.arg.isConst = isConst;
            	  		retval.arg.key = retval.ckey;
            	  	
            	}
            	name=(IToken)Match(input,WORD,FOLLOW_WORD_in_ordinary_argument302); if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.arg.name = name.Text; 
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:101:2: ( EQUAL exp= expression )?
            	int alt8 = 2;
            	int LA8_0 = input.LA(1);

            	if ( (LA8_0 == EQUAL) )
            	{
            	    alt8 = 1;
            	}
            	switch (alt8) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:101:3: EQUAL exp= expression
            	        {
            	        	Match(input,EQUAL,FOLLOW_EQUAL_in_ordinary_argument308); if (state.failed) return retval;
            	        	PushFollow(FOLLOW_expression_in_ordinary_argument312);
            	        	exp = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.arg.defaultValue = exp; 
            	        	}

            	        }
            	        break;

            	}

            	if ( state.backtracking == 0 ) 
            	{
            	  retval.arg.EndToken = input.LT(-1).ToSource(); 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "ordinary_argument"


    // $ANTLR start "vararg_argument"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:105:1: vararg_argument[bool isConst] returns [T.FunctionArgument arg] : ( VAR | CONST )? n= WORD e= ELLIPSIS ;
    public T.FunctionArgument vararg_argument(bool isConst) // throws RecognitionException [1]
    {   
        T.FunctionArgument arg = default(T.FunctionArgument);

        IToken n = null;
        IToken e = null;

        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:106:2: ( ( VAR | CONST )? n= WORD e= ELLIPSIS )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:107:2: ( VAR | CONST )? n= WORD e= ELLIPSIS
            {
            	if ( state.backtracking == 0 ) 
            	{

            	  		arg =  new T.FunctionArgument();
            	  		arg.isVarArgs = true;
            	  		arg.StartToken = input.LT(1).ToSource();
            	  	
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:112:2: ( VAR | CONST )?
            	int alt9 = 3;
            	int LA9_0 = input.LA(1);

            	if ( (LA9_0 == VAR) )
            	{
            	    alt9 = 1;
            	}
            	else if ( (LA9_0 == CONST) )
            	{
            	    alt9 = 2;
            	}
            	switch (alt9) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:112:3: VAR
            	        {
            	        	Match(input,VAR,FOLLOW_VAR_in_vararg_argument341); if (state.failed) return arg;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	   isConst =  false; 
            	        	}

            	        }
            	        break;
            	    case 2 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:112:31: CONST
            	        {
            	        	Match(input,CONST,FOLLOW_CONST_in_vararg_argument347); if (state.failed) return arg;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	   isConst =  true; 
            	        	}

            	        }
            	        break;

            	}

            	if ( state.backtracking == 0 ) 
            	{

            	  		arg.isConst = isConst;
            	  	
            	}
            	n=(IToken)Match(input,WORD,FOLLOW_WORD_in_vararg_argument359); if (state.failed) return arg;
            	if ( state.backtracking == 0 ) 
            	{
            	  arg.name = n.Text; 
            	}
            	e=(IToken)Match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_vararg_argument366); if (state.failed) return arg;
            	if ( state.backtracking == 0 ) 
            	{
            	  arg.EndToken = e.ToSource(); 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return arg;
    }
    // $ANTLR end "vararg_argument"


    // $ANTLR start "statement"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:120:1: statement returns [T.Statement stmt] : (b= block | n= unitstmt | i= ifstmt | w= whilestmt | f= forstmt );
    public T.Statement statement() // throws RecognitionException [1]
    {   
        T.Statement stmt = default(T.Statement);

        T.Block b = default(T.Block);

        T.Statement n = default(T.Statement);

        pinedl.ifstmt_return i = default(pinedl.ifstmt_return);

        pinedl.whilestmt_return w = default(pinedl.whilestmt_return);

        pinedl.forstmt_return f = default(pinedl.forstmt_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:121:2: (b= block | n= unitstmt | i= ifstmt | w= whilestmt | f= forstmt )
            int alt10 = 5;
            switch ( input.LA(1) ) 
            {
            case LBLOCK:
            	{
                alt10 = 1;
                }
                break;
            case FUNCTION:
            case LPAREN:
            case VAR:
            case CONST:
            case NUMBER:
            case STRINGCONST:
            case SEMICOLON:
            case RETURN:
            case BREAK:
            case CONTINUE:
            case DO:
            case LARRAY:
            case NUMBERKEYWORD:
            case CHARCONST:
            case TRUE:
            case FALSE:
            case NULL:
            case THIS:
            case CALLEE:
            case INCREMENT:
            case DECREMENT:
            case PLUS:
            case MINUS:
            case BITNOT:
            case LOGNOT:
            	{
                alt10 = 2;
                }
                break;
            case WORD:
            	{
                int LA10_3 = input.LA(2);

                if ( (LA10_3 == LPAREN || LA10_3 == COMMA || LA10_3 == EQUAL || LA10_3 == SEMICOLON || LA10_3 == LARRAY || (LA10_3 >= DOT && LA10_3 <= MINUS) || (LA10_3 >= MULT && LA10_3 <= LOGICALOR)) )
                {
                    alt10 = 2;
                }
                else if ( (LA10_3 == COLON) )
                {
                    switch ( input.LA(3) ) 
                    {
                    case FUNCTION:
                    case WORD:
                    case LPAREN:
                    case NUMBER:
                    case STRINGCONST:
                    case DO:
                    case LARRAY:
                    case NUMBERKEYWORD:
                    case CHARCONST:
                    case TRUE:
                    case FALSE:
                    case NULL:
                    case THIS:
                    case CALLEE:
                    case INCREMENT:
                    case DECREMENT:
                    case PLUS:
                    case MINUS:
                    case BITNOT:
                    case LOGNOT:
                    	{
                        alt10 = 2;
                        }
                        break;
                    case FOR:
                    	{
                        alt10 = 5;
                        }
                        break;
                    case WHILE:
                    	{
                        alt10 = 4;
                        }
                        break;
                    	default:
                    	    if ( state.backtracking > 0 ) {state.failed = true; return stmt;}
                    	    NoViableAltException nvae_d10s7 =
                    	        new NoViableAltException("", 10, 7, input);

                    	    throw nvae_d10s7;
                    }

                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return stmt;}
                    NoViableAltException nvae_d10s3 =
                        new NoViableAltException("", 10, 3, input);

                    throw nvae_d10s3;
                }
                }
                break;
            case IF:
            	{
                alt10 = 3;
                }
                break;
            case WHILE:
            	{
                alt10 = 4;
                }
                break;
            case FOR:
            	{
                alt10 = 5;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return stmt;}
            	    NoViableAltException nvae_d10s0 =
            	        new NoViableAltException("", 10, 0, input);

            	    throw nvae_d10s0;
            }

            switch (alt10) 
            {
                case 1 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:121:4: b= block
                    {
                    	PushFollow(FOLLOW_block_in_statement385);
                    	b = block();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  b; 
                    	}

                    }
                    break;
                case 2 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:122:5: n= unitstmt
                    {
                    	PushFollow(FOLLOW_unitstmt_in_statement395);
                    	n = unitstmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  n; 
                    	}

                    }
                    break;
                case 3 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:123:4: i= ifstmt
                    {
                    	PushFollow(FOLLOW_ifstmt_in_statement404);
                    	i = ifstmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  ((i != null) ? i.stmt : default(T.ConditionalStatement)); 
                    	}

                    }
                    break;
                case 4 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:124:4: w= whilestmt
                    {
                    	PushFollow(FOLLOW_whilestmt_in_statement413);
                    	w = whilestmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  ((w != null) ? w.stmt : default(T.WhileStatement)); 
                    	}

                    }
                    break;
                case 5 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:125:4: f= forstmt
                    {
                    	PushFollow(FOLLOW_forstmt_in_statement422);
                    	f = forstmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  ((f != null) ? f.stmt : default(T.ForStatement)); 
                    	}

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return stmt;
    }
    // $ANTLR end "statement"


    // $ANTLR start "unitstmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:127:1: unitstmt returns [T.Statement stmt] : ( (s= semicolonstmt SEMICOLON ) | SEMICOLON );
    public T.Statement unitstmt() // throws RecognitionException [1]
    {   
        T.Statement stmt = default(T.Statement);

        T.Statement s = default(T.Statement);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:128:1: ( (s= semicolonstmt SEMICOLON ) | SEMICOLON )
            int alt11 = 2;
            int LA11_0 = input.LA(1);

            if ( ((LA11_0 >= FUNCTION && LA11_0 <= LPAREN) || (LA11_0 >= VAR && LA11_0 <= STRINGCONST) || (LA11_0 >= RETURN && LA11_0 <= CONTINUE) || LA11_0 == DO || LA11_0 == LARRAY || (LA11_0 >= NUMBERKEYWORD && LA11_0 <= CALLEE) || (LA11_0 >= INCREMENT && LA11_0 <= LOGNOT)) )
            {
                alt11 = 1;
            }
            else if ( (LA11_0 == SEMICOLON) )
            {
                alt11 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return stmt;}
                NoViableAltException nvae_d11s0 =
                    new NoViableAltException("", 11, 0, input);

                throw nvae_d11s0;
            }
            switch (alt11) 
            {
                case 1 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:128:3: (s= semicolonstmt SEMICOLON )
                    {
                    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:128:3: (s= semicolonstmt SEMICOLON )
                    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:128:4: s= semicolonstmt SEMICOLON
                    	{
                    		PushFollow(FOLLOW_semicolonstmt_in_unitstmt441);
                    		s = semicolonstmt();
                    		state.followingStackPointer--;
                    		if (state.failed) return stmt;
                    		if ( state.backtracking == 0 ) 
                    		{
                    		  stmt =  s;
                    		}
                    		Match(input,SEMICOLON,FOLLOW_SEMICOLON_in_unitstmt445); if (state.failed) return stmt;
                    		if ( state.backtracking == 0 ) 
                    		{
                    		  s.EndToken = input.LT(-1).ToSource(); 
                    		}

                    	}


                    }
                    break;
                case 2 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:129:4: SEMICOLON
                    {
                    	Match(input,SEMICOLON,FOLLOW_SEMICOLON_in_unitstmt453); if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  new T.EmptyStatement(); stmt.StartToken = stmt.EndToken = input.LT(-1).ToSource(); 
                    	}

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return stmt;
    }
    // $ANTLR end "unitstmt"


    // $ANTLR start "semicolonstmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:132:1: semicolonstmt returns [T.Statement stmt] : ( ( RETURN ELLIPSIS )=>r2= returnellipsisstmt | ( ( WORD COLON )? DO )=>dow= dowhilestmt | r= returnstmt | ( assignmentrightlist )=>a= assignmentrightlist | e= expressionstmt | d= declarationstmt | b= breakstmt | c= continuestmt );
    public T.Statement semicolonstmt() // throws RecognitionException [1]
    {   
        T.Statement stmt = default(T.Statement);

        T.ReturnEllipsisStatement r2 = default(T.ReturnEllipsisStatement);

        pinedl.dowhilestmt_return dow = default(pinedl.dowhilestmt_return);

        T.ReturnStatement r = default(T.ReturnStatement);

        T.AssignmentRightList a = default(T.AssignmentRightList);

        T.ExpressionStatement e = default(T.ExpressionStatement);

        pinedl.declarationstmt_return d = default(pinedl.declarationstmt_return);

        pinedl.breakstmt_return b = default(pinedl.breakstmt_return);

        pinedl.continuestmt_return c = default(pinedl.continuestmt_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:132:41: ( ( RETURN ELLIPSIS )=>r2= returnellipsisstmt | ( ( WORD COLON )? DO )=>dow= dowhilestmt | r= returnstmt | ( assignmentrightlist )=>a= assignmentrightlist | e= expressionstmt | d= declarationstmt | b= breakstmt | c= continuestmt )
            int alt12 = 8;
            alt12 = dfa12.Predict(input);
            switch (alt12) 
            {
                case 1 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:133:2: ( RETURN ELLIPSIS )=>r2= returnellipsisstmt
                    {
                    	PushFollow(FOLLOW_returnellipsisstmt_in_semicolonstmt477);
                    	r2 = returnellipsisstmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  r2; 
                    	}

                    }
                    break;
                case 2 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:134:4: ( ( WORD COLON )? DO )=>dow= dowhilestmt
                    {
                    	PushFollow(FOLLOW_dowhilestmt_in_semicolonstmt498);
                    	dow = dowhilestmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  ((dow != null) ? dow.stmt : default(T.DoWhileStatement)); 
                    	}

                    }
                    break;
                case 3 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:135:4: r= returnstmt
                    {
                    	PushFollow(FOLLOW_returnstmt_in_semicolonstmt507);
                    	r = returnstmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  r; 
                    	}

                    }
                    break;
                case 4 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:136:4: ( assignmentrightlist )=>a= assignmentrightlist
                    {
                    	PushFollow(FOLLOW_assignmentrightlist_in_semicolonstmt520);
                    	a = assignmentrightlist();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  new T.AssignmentStatement(a); stmt.StartToken = a.StartToken; 
                    	}

                    }
                    break;
                case 5 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:137:4: e= expressionstmt
                    {
                    	PushFollow(FOLLOW_expressionstmt_in_semicolonstmt529);
                    	e = expressionstmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  e; 
                    	}

                    }
                    break;
                case 6 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:138:4: d= declarationstmt
                    {
                    	PushFollow(FOLLOW_declarationstmt_in_semicolonstmt538);
                    	d = declarationstmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  ((d != null) ? d.stmt : default(T.DeclarationStatement)); 
                    	}

                    }
                    break;
                case 7 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:139:4: b= breakstmt
                    {
                    	PushFollow(FOLLOW_breakstmt_in_semicolonstmt547);
                    	b = breakstmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  ((b != null) ? b.stmt : default(T.BreakStatement)); 
                    	}

                    }
                    break;
                case 8 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:140:4: c= continuestmt
                    {
                    	PushFollow(FOLLOW_continuestmt_in_semicolonstmt556);
                    	c = continuestmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return stmt;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   stmt =  ((c != null) ? c.stmt : default(T.ContinueStatement)); 
                    	}

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return stmt;
    }
    // $ANTLR end "semicolonstmt"


    // $ANTLR start "expressionstmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:143:1: expressionstmt returns [T.ExpressionStatement stmt] : (e= expression ) ;
    public T.ExpressionStatement expressionstmt() // throws RecognitionException [1]
    {   
        T.ExpressionStatement stmt = default(T.ExpressionStatement);

        T.Expression e = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:144:2: ( (e= expression ) )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:145:3: (e= expression )
            {
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:145:3: (e= expression )
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:145:4: e= expression
            	{
            		PushFollow(FOLLOW_expression_in_expressionstmt578);
            		e = expression();
            		state.followingStackPointer--;
            		if (state.failed) return stmt;
            		if ( state.backtracking == 0 ) 
            		{
            		  stmt =  new T.ExpressionStatement(e); stmt.StartToken = e.StartToken; 
            		}

            	}


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return stmt;
    }
    // $ANTLR end "expressionstmt"


    // $ANTLR start "block"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:147:1: block returns [T.Block stmt] : LBLOCK (s= statement )* RBLOCK ;
    public T.Block block() // throws RecognitionException [1]
    {   
        T.Block stmt = default(T.Block);

        T.Statement s = default(T.Statement);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:148:2: ( LBLOCK (s= statement )* RBLOCK )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:148:4: LBLOCK (s= statement )* RBLOCK
            {
            	if ( state.backtracking == 0 ) 
            	{
            	   stmt =  new T.Block(); stmt.StartToken = input.LT(1).ToSource(); 
            	}
            	Match(input,LBLOCK,FOLLOW_LBLOCK_in_block598); if (state.failed) return stmt;
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:149:10: (s= statement )*
            	do 
            	{
            	    int alt13 = 2;
            	    int LA13_0 = input.LA(1);

            	    if ( ((LA13_0 >= FUNCTION && LA13_0 <= LPAREN) || (LA13_0 >= VAR && LA13_0 <= STRINGCONST) || (LA13_0 >= SEMICOLON && LA13_0 <= LBLOCK) || (LA13_0 >= RETURN && LA13_0 <= IF) || (LA13_0 >= WHILE && LA13_0 <= LARRAY) || (LA13_0 >= NUMBERKEYWORD && LA13_0 <= CALLEE) || (LA13_0 >= INCREMENT && LA13_0 <= LOGNOT)) )
            	    {
            	        alt13 = 1;
            	    }


            	    switch (alt13) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:149:11: s= statement
            			    {
            			    	PushFollow(FOLLOW_statement_in_block603);
            			    	s = statement();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return stmt;
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  stmt.content.Add(s); 
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop13;
            	    }
            	} while (true);

            	loop13:
            		;	// Stops C# compiler whining that label 'loop13' has no statements

            	Match(input,RBLOCK,FOLLOW_RBLOCK_in_block609); if (state.failed) return stmt;
            	if ( state.backtracking == 0 ) 
            	{
            	   stmt.EndToken = input.LT(-1).ToSource(); 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return stmt;
    }
    // $ANTLR end "block"


    // $ANTLR start "returnstmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:152:1: returnstmt returns [T.ReturnStatement stmt] : ret= RETURN rl= rightlist ;
    public T.ReturnStatement returnstmt() // throws RecognitionException [1]
    {   
        T.ReturnStatement stmt = default(T.ReturnStatement);

        IToken ret = null;
        T.RightList rl = default(T.RightList);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:153:2: (ret= RETURN rl= rightlist )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:153:4: ret= RETURN rl= rightlist
            {
            	ret=(IToken)Match(input,RETURN,FOLLOW_RETURN_in_returnstmt628); if (state.failed) return stmt;
            	PushFollow(FOLLOW_rightlist_in_returnstmt632);
            	rl = rightlist();
            	state.followingStackPointer--;
            	if (state.failed) return stmt;
            	if ( state.backtracking == 0 ) 
            	{
            	  stmt =  new T.ReturnStatement(rl); stmt.StartToken = ret.ToSource(); 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return stmt;
    }
    // $ANTLR end "returnstmt"


    // $ANTLR start "returnellipsisstmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:155:1: returnellipsisstmt returns [T.ReturnEllipsisStatement stmt] : ret= RETURN ELLIPSIS a= atom ;
    public T.ReturnEllipsisStatement returnellipsisstmt() // throws RecognitionException [1]
    {   
        T.ReturnEllipsisStatement stmt = default(T.ReturnEllipsisStatement);

        IToken ret = null;
        pinedl.atom_return a = default(pinedl.atom_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:156:2: (ret= RETURN ELLIPSIS a= atom )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:156:4: ret= RETURN ELLIPSIS a= atom
            {
            	ret=(IToken)Match(input,RETURN,FOLLOW_RETURN_in_returnellipsisstmt649); if (state.failed) return stmt;
            	Match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_returnellipsisstmt651); if (state.failed) return stmt;
            	PushFollow(FOLLOW_atom_in_returnellipsisstmt655);
            	a = atom();
            	state.followingStackPointer--;
            	if (state.failed) return stmt;
            	if ( state.backtracking == 0 ) 
            	{
            	  stmt =  new T.ReturnEllipsisStatement(((a != null) ? a.e : default(T.Expression))); stmt.StartToken = ret.ToSource(); 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return stmt;
    }
    // $ANTLR end "returnellipsisstmt"

    public class breakstmt_return : ParserRuleReturnScope
    {
        public T.BreakStatement stmt;
        public string loopName;
    };

    // $ANTLR start "breakstmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:158:1: breakstmt returns [T.BreakStatement stmt, string loopName] : b= BREAK (w= WORD )? ;
    public pinedl.breakstmt_return breakstmt() // throws RecognitionException [1]
    {   
        pinedl.breakstmt_return retval = new pinedl.breakstmt_return();
        retval.Start = input.LT(1);

        IToken b = null;
        IToken w = null;

        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:159:2: (b= BREAK (w= WORD )? )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:160:2: b= BREAK (w= WORD )?
            {
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.loopName =  null;
            	}
            	b=(IToken)Match(input,BREAK,FOLLOW_BREAK_in_breakstmt676); if (state.failed) return retval;
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:161:10: (w= WORD )?
            	int alt14 = 2;
            	int LA14_0 = input.LA(1);

            	if ( (LA14_0 == WORD) )
            	{
            	    alt14 = 1;
            	}
            	switch (alt14) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:161:11: w= WORD
            	        {
            	        	w=(IToken)Match(input,WORD,FOLLOW_WORD_in_breakstmt681); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.loopName =  w.Text;
            	        	}

            	        }
            	        break;

            	}

            	if ( state.backtracking == 0 ) 
            	{
            	  retval.stmt =  new T.BreakStatement(retval.loopName); retval.stmt.StartToken = b.ToSource(); 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "breakstmt"

    public class continuestmt_return : ParserRuleReturnScope
    {
        public T.ContinueStatement stmt;
        public string loopName;
    };

    // $ANTLR start "continuestmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:163:1: continuestmt returns [T.ContinueStatement stmt, string loopName] : c= CONTINUE (w= WORD )? ;
    public pinedl.continuestmt_return continuestmt() // throws RecognitionException [1]
    {   
        pinedl.continuestmt_return retval = new pinedl.continuestmt_return();
        retval.Start = input.LT(1);

        IToken c = null;
        IToken w = null;

        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:164:2: (c= CONTINUE (w= WORD )? )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:165:2: c= CONTINUE (w= WORD )?
            {
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.loopName =  null;
            	}
            	c=(IToken)Match(input,CONTINUE,FOLLOW_CONTINUE_in_continuestmt706); if (state.failed) return retval;
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:166:13: (w= WORD )?
            	int alt15 = 2;
            	int LA15_0 = input.LA(1);

            	if ( (LA15_0 == WORD) )
            	{
            	    alt15 = 1;
            	}
            	switch (alt15) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:166:14: w= WORD
            	        {
            	        	w=(IToken)Match(input,WORD,FOLLOW_WORD_in_continuestmt711); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.loopName =  w.Text;
            	        	}

            	        }
            	        break;

            	}

            	if ( state.backtracking == 0 ) 
            	{
            	  retval.stmt =  new T.ContinueStatement(retval.loopName); retval.stmt.StartToken = c.ToSource(); 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "continuestmt"

    public class ifstmt_return : ParserRuleReturnScope
    {
        public T.ConditionalStatement stmt;
        public T.Statement elsestmt;
    };

    // $ANTLR start "ifstmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:168:1: ifstmt returns [T.ConditionalStatement stmt, T.Statement elsestmt] : iftoken= IF LPAREN condition= expression RPAREN i= statement ( ( ELSE )=> ELSE e= statement )? ;
    public pinedl.ifstmt_return ifstmt() // throws RecognitionException [1]
    {   
        pinedl.ifstmt_return retval = new pinedl.ifstmt_return();
        retval.Start = input.LT(1);

        IToken iftoken = null;
        T.Expression condition = default(T.Expression);

        T.Statement i = default(T.Statement);

        T.Statement e = default(T.Statement);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:169:2: (iftoken= IF LPAREN condition= expression RPAREN i= statement ( ( ELSE )=> ELSE e= statement )? )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:169:4: iftoken= IF LPAREN condition= expression RPAREN i= statement ( ( ELSE )=> ELSE e= statement )?
            {
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.elsestmt =  null;
            	}
            	iftoken=(IToken)Match(input,IF,FOLLOW_IF_in_ifstmt735); if (state.failed) return retval;
            	Match(input,LPAREN,FOLLOW_LPAREN_in_ifstmt737); if (state.failed) return retval;
            	PushFollow(FOLLOW_expression_in_ifstmt741);
            	condition = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	Match(input,RPAREN,FOLLOW_RPAREN_in_ifstmt743); if (state.failed) return retval;
            	PushFollow(FOLLOW_statement_in_ifstmt748);
            	i = statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:172:2: ( ( ELSE )=> ELSE e= statement )?
            	int alt16 = 2;
            	int LA16_0 = input.LA(1);

            	if ( (LA16_0 == ELSE) )
            	{
            	    int LA16_1 = input.LA(2);

            	    if ( (synpred4_pinedl()) )
            	    {
            	        alt16 = 1;
            	    }
            	}
            	switch (alt16) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:172:3: ( ELSE )=> ELSE e= statement
            	        {
            	        	Match(input,ELSE,FOLLOW_ELSE_in_ifstmt758); if (state.failed) return retval;
            	        	PushFollow(FOLLOW_statement_in_ifstmt762);
            	        	e = statement();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.elsestmt =  e;
            	        	}

            	        }
            	        break;

            	}

            	if ( state.backtracking == 0 ) 
            	{
            	  retval.stmt =  new T.ConditionalStatement(condition, i, retval.elsestmt); retval.stmt.StartToken = iftoken.ToSource(); retval.stmt.EndToken = input.LT(-1).ToSource(); 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "ifstmt"

    public class whilestmt_return : ParserRuleReturnScope
    {
        public string name;
        public T.WhileStatement stmt;
    };

    // $ANTLR start "whilestmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:175:1: whilestmt returns [string name, T.WhileStatement stmt] : (w= WORD COLON )? WHILE LPAREN condition= expression RPAREN s= statement ;
    public pinedl.whilestmt_return whilestmt() // throws RecognitionException [1]
    {   
        pinedl.whilestmt_return retval = new pinedl.whilestmt_return();
        retval.Start = input.LT(1);

        IToken w = null;
        T.Expression condition = default(T.Expression);

        T.Statement s = default(T.Statement);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:176:2: ( (w= WORD COLON )? WHILE LPAREN condition= expression RPAREN s= statement )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:176:4: (w= WORD COLON )? WHILE LPAREN condition= expression RPAREN s= statement
            {
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.name =  null;  
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:177:2: (w= WORD COLON )?
            	int alt17 = 2;
            	int LA17_0 = input.LA(1);

            	if ( (LA17_0 == WORD) )
            	{
            	    alt17 = 1;
            	}
            	switch (alt17) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:177:3: w= WORD COLON
            	        {
            	        	w=(IToken)Match(input,WORD,FOLLOW_WORD_in_whilestmt788); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.name =  w.Text;
            	        	}
            	        	Match(input,COLON,FOLLOW_COLON_in_whilestmt792); if (state.failed) return retval;

            	        }
            	        break;

            	}

            	Match(input,WHILE,FOLLOW_WHILE_in_whilestmt799); if (state.failed) return retval;
            	Match(input,LPAREN,FOLLOW_LPAREN_in_whilestmt801); if (state.failed) return retval;
            	PushFollow(FOLLOW_expression_in_whilestmt805);
            	condition = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	Match(input,RPAREN,FOLLOW_RPAREN_in_whilestmt807); if (state.failed) return retval;
            	PushFollow(FOLLOW_statement_in_whilestmt812);
            	s = statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.stmt =  new T.WhileStatement(retval.name, condition, s); retval.stmt.StartToken = ((IToken) retval.Start).ToSource(); retval.stmt.EndToken = input.LT(-1).ToSource(); 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "whilestmt"

    public class dowhilestmt_return : ParserRuleReturnScope
    {
        public string name;
        public T.DoWhileStatement stmt;
    };

    // $ANTLR start "dowhilestmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:182:1: dowhilestmt returns [string name, T.DoWhileStatement stmt] : (w= WORD COLON )? DO s= statement WHILE LPAREN condition= expression RPAREN ;
    public pinedl.dowhilestmt_return dowhilestmt() // throws RecognitionException [1]
    {   
        pinedl.dowhilestmt_return retval = new pinedl.dowhilestmt_return();
        retval.Start = input.LT(1);

        IToken w = null;
        T.Statement s = default(T.Statement);

        T.Expression condition = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:183:2: ( (w= WORD COLON )? DO s= statement WHILE LPAREN condition= expression RPAREN )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:183:4: (w= WORD COLON )? DO s= statement WHILE LPAREN condition= expression RPAREN
            {
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.name =  null; 
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:184:2: (w= WORD COLON )?
            	int alt18 = 2;
            	int LA18_0 = input.LA(1);

            	if ( (LA18_0 == WORD) )
            	{
            	    alt18 = 1;
            	}
            	switch (alt18) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:184:3: w= WORD COLON
            	        {
            	        	w=(IToken)Match(input,WORD,FOLLOW_WORD_in_dowhilestmt835); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.name =  w.Text;
            	        	}
            	        	Match(input,COLON,FOLLOW_COLON_in_dowhilestmt839); if (state.failed) return retval;

            	        }
            	        break;

            	}

            	Match(input,DO,FOLLOW_DO_in_dowhilestmt846); if (state.failed) return retval;
            	PushFollow(FOLLOW_statement_in_dowhilestmt851);
            	s = statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	Match(input,WHILE,FOLLOW_WHILE_in_dowhilestmt854); if (state.failed) return retval;
            	Match(input,LPAREN,FOLLOW_LPAREN_in_dowhilestmt856); if (state.failed) return retval;
            	PushFollow(FOLLOW_expression_in_dowhilestmt860);
            	condition = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	Match(input,RPAREN,FOLLOW_RPAREN_in_dowhilestmt862); if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.stmt =  new T.DoWhileStatement(retval.name, condition, s); retval.stmt.StartToken = ((IToken) retval.Start).ToSource(); 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "dowhilestmt"

    public class forstmt_return : ParserRuleReturnScope
    {
        public string name;
        public T.ForStatement stmt;
        public T.Expression e;
        public T.Statement endStmt;
    };

    // $ANTLR start "forstmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:190:1: forstmt returns [string name, T.ForStatement stmt, T.Expression e, T.Statement endStmt] : (w= WORD COLON )? FOR LPAREN begin= unitstmt (c= expression )? SEMICOLON (end= expressionstmt )? RPAREN content= statement ;
    public pinedl.forstmt_return forstmt() // throws RecognitionException [1]
    {   
        pinedl.forstmt_return retval = new pinedl.forstmt_return();
        retval.Start = input.LT(1);

        IToken w = null;
        T.Statement begin = default(T.Statement);

        T.Expression c = default(T.Expression);

        T.ExpressionStatement end = default(T.ExpressionStatement);

        T.Statement content = default(T.Statement);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:190:89: ( (w= WORD COLON )? FOR LPAREN begin= unitstmt (c= expression )? SEMICOLON (end= expressionstmt )? RPAREN content= statement )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:191:2: (w= WORD COLON )? FOR LPAREN begin= unitstmt (c= expression )? SEMICOLON (end= expressionstmt )? RPAREN content= statement
            {
            	if ( state.backtracking == 0 ) 
            	{
            	   retval.name =  null; 
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:192:2: (w= WORD COLON )?
            	int alt19 = 2;
            	int LA19_0 = input.LA(1);

            	if ( (LA19_0 == WORD) )
            	{
            	    alt19 = 1;
            	}
            	switch (alt19) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:192:3: w= WORD COLON
            	        {
            	        	w=(IToken)Match(input,WORD,FOLLOW_WORD_in_forstmt884); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.name =  w.Text;
            	        	}
            	        	Match(input,COLON,FOLLOW_COLON_in_forstmt888); if (state.failed) return retval;

            	        }
            	        break;

            	}

            	Match(input,FOR,FOLLOW_FOR_in_forstmt898); if (state.failed) return retval;
            	Match(input,LPAREN,FOLLOW_LPAREN_in_forstmt900); if (state.failed) return retval;
            	PushFollow(FOLLOW_unitstmt_in_forstmt904);
            	begin = unitstmt();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:194:28: (c= expression )?
            	int alt20 = 2;
            	int LA20_0 = input.LA(1);

            	if ( ((LA20_0 >= FUNCTION && LA20_0 <= LPAREN) || (LA20_0 >= NUMBER && LA20_0 <= STRINGCONST) || LA20_0 == LARRAY || (LA20_0 >= NUMBERKEYWORD && LA20_0 <= CALLEE) || (LA20_0 >= INCREMENT && LA20_0 <= LOGNOT)) )
            	{
            	    alt20 = 1;
            	}
            	switch (alt20) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:194:29: c= expression
            	        {
            	        	PushFollow(FOLLOW_expression_in_forstmt911);
            	        	c = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.e =  c;
            	        	}

            	        }
            	        break;

            	}

            	Match(input,SEMICOLON,FOLLOW_SEMICOLON_in_forstmt917); if (state.failed) return retval;
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:194:69: (end= expressionstmt )?
            	int alt21 = 2;
            	int LA21_0 = input.LA(1);

            	if ( ((LA21_0 >= FUNCTION && LA21_0 <= LPAREN) || (LA21_0 >= NUMBER && LA21_0 <= STRINGCONST) || LA21_0 == LARRAY || (LA21_0 >= NUMBERKEYWORD && LA21_0 <= CALLEE) || (LA21_0 >= INCREMENT && LA21_0 <= LOGNOT)) )
            	{
            	    alt21 = 1;
            	}
            	switch (alt21) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:194:70: end= expressionstmt
            	        {
            	        	PushFollow(FOLLOW_expressionstmt_in_forstmt922);
            	        	end = expressionstmt();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.endStmt =  end;
            	        	}

            	        }
            	        break;

            	}

            	Match(input,RPAREN,FOLLOW_RPAREN_in_forstmt928); if (state.failed) return retval;
            	PushFollow(FOLLOW_statement_in_forstmt933);
            	content = statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.stmt =  new T.ForStatement(retval.name, begin, retval.e, retval.endStmt, content); retval.stmt.StartToken = ((IToken) retval.Start).ToSource(); retval.stmt.EndToken = content.EndToken; 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "forstmt"


    // $ANTLR start "arrayconst"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:198:1: arrayconst returns [T.ArrayConstant a] : l= LARRAY (e1= expression ARRAYKEYVALUE e2= expression ( COMMA e3= expression ARRAYKEYVALUE e4= expression )* )? r= RARRAY ;
    public T.ArrayConstant arrayconst() // throws RecognitionException [1]
    {   
        T.ArrayConstant a = default(T.ArrayConstant);

        IToken l = null;
        IToken r = null;
        T.Expression e1 = default(T.Expression);

        T.Expression e2 = default(T.Expression);

        T.Expression e3 = default(T.Expression);

        T.Expression e4 = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:198:39: (l= LARRAY (e1= expression ARRAYKEYVALUE e2= expression ( COMMA e3= expression ARRAYKEYVALUE e4= expression )* )? r= RARRAY )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:199:2: l= LARRAY (e1= expression ARRAYKEYVALUE e2= expression ( COMMA e3= expression ARRAYKEYVALUE e4= expression )* )? r= RARRAY
            {
            	l=(IToken)Match(input,LARRAY,FOLLOW_LARRAY_in_arrayconst950); if (state.failed) return a;
            	if ( state.backtracking == 0 ) 
            	{
            	  a =  new T.ArrayConstant(); a.StartToken = l.ToSource(); 
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:201:2: (e1= expression ARRAYKEYVALUE e2= expression ( COMMA e3= expression ARRAYKEYVALUE e4= expression )* )?
            	int alt23 = 2;
            	int LA23_0 = input.LA(1);

            	if ( ((LA23_0 >= FUNCTION && LA23_0 <= LPAREN) || (LA23_0 >= NUMBER && LA23_0 <= STRINGCONST) || LA23_0 == LARRAY || (LA23_0 >= NUMBERKEYWORD && LA23_0 <= CALLEE) || (LA23_0 >= INCREMENT && LA23_0 <= LOGNOT)) )
            	{
            	    alt23 = 1;
            	}
            	switch (alt23) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:202:3: e1= expression ARRAYKEYVALUE e2= expression ( COMMA e3= expression ARRAYKEYVALUE e4= expression )*
            	        {
            	        	PushFollow(FOLLOW_expression_in_arrayconst962);
            	        	e1 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return a;
            	        	Match(input,ARRAYKEYVALUE,FOLLOW_ARRAYKEYVALUE_in_arrayconst964); if (state.failed) return a;
            	        	PushFollow(FOLLOW_expression_in_arrayconst968);
            	        	e2 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return a;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	   a.arrayMembers.Add(new T.ArrayMember(e1, e2)); 
            	        	}
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:203:3: ( COMMA e3= expression ARRAYKEYVALUE e4= expression )*
            	        	do 
            	        	{
            	        	    int alt22 = 2;
            	        	    int LA22_0 = input.LA(1);

            	        	    if ( (LA22_0 == COMMA) )
            	        	    {
            	        	        alt22 = 1;
            	        	    }


            	        	    switch (alt22) 
            	        		{
            	        			case 1 :
            	        			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:203:4: COMMA e3= expression ARRAYKEYVALUE e4= expression
            	        			    {
            	        			    	Match(input,COMMA,FOLLOW_COMMA_in_arrayconst975); if (state.failed) return a;
            	        			    	PushFollow(FOLLOW_expression_in_arrayconst979);
            	        			    	e3 = expression();
            	        			    	state.followingStackPointer--;
            	        			    	if (state.failed) return a;
            	        			    	Match(input,ARRAYKEYVALUE,FOLLOW_ARRAYKEYVALUE_in_arrayconst981); if (state.failed) return a;
            	        			    	PushFollow(FOLLOW_expression_in_arrayconst985);
            	        			    	e4 = expression();
            	        			    	state.followingStackPointer--;
            	        			    	if (state.failed) return a;
            	        			    	if ( state.backtracking == 0 ) 
            	        			    	{
            	        			    	   a.arrayMembers.Add(new T.ArrayMember(e3, e4)); 
            	        			    	}

            	        			    }
            	        			    break;

            	        			default:
            	        			    goto loop22;
            	        	    }
            	        	} while (true);

            	        	loop22:
            	        		;	// Stops C# compiler whining that label 'loop22' has no statements


            	        }
            	        break;

            	}

            	r=(IToken)Match(input,RARRAY,FOLLOW_RARRAY_in_arrayconst997); if (state.failed) return a;
            	if ( state.backtracking == 0 ) 
            	{
            	  a.EndToken = r.ToSource(); 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return a;
    }
    // $ANTLR end "arrayconst"


    // $ANTLR start "typeconst"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:207:1: typeconst returns [T.TypeConstant t] : num= NUMBERKEYWORD ;
    public T.TypeConstant typeconst() // throws RecognitionException [1]
    {   
        T.TypeConstant t = default(T.TypeConstant);

        IToken num = null;

        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:207:37: (num= NUMBERKEYWORD )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:208:2: num= NUMBERKEYWORD
            {
            	num=(IToken)Match(input,NUMBERKEYWORD,FOLLOW_NUMBERKEYWORD_in_typeconst1014); if (state.failed) return t;
            	if ( state.backtracking == 0 ) 
            	{
            	  t =  new T.TypeConstant(T.TypeConstantType.Number); t.StartToken = t.EndToken = num.ToSource(); 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return t;
    }
    // $ANTLR end "typeconst"


    // $ANTLR start "constant"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:211:1: constant returns [T.Constant c] : (n= NUMBER | s= STRINGCONST | ch= CHARCONST | tr= TRUE | fa= FALSE | nullToken= NULL | THIS | CALLEE | a= arrayconst | f= functiondecl | t= typeconst );
    public T.Constant constant() // throws RecognitionException [1]
    {   
        T.Constant c = default(T.Constant);

        IToken n = null;
        IToken s = null;
        IToken ch = null;
        IToken tr = null;
        IToken fa = null;
        IToken nullToken = null;
        T.ArrayConstant a = default(T.ArrayConstant);

        T.Function f = default(T.Function);

        T.TypeConstant t = default(T.TypeConstant);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:212:2: (n= NUMBER | s= STRINGCONST | ch= CHARCONST | tr= TRUE | fa= FALSE | nullToken= NULL | THIS | CALLEE | a= arrayconst | f= functiondecl | t= typeconst )
            int alt24 = 11;
            switch ( input.LA(1) ) 
            {
            case NUMBER:
            	{
                alt24 = 1;
                }
                break;
            case STRINGCONST:
            	{
                alt24 = 2;
                }
                break;
            case CHARCONST:
            	{
                alt24 = 3;
                }
                break;
            case TRUE:
            	{
                alt24 = 4;
                }
                break;
            case FALSE:
            	{
                alt24 = 5;
                }
                break;
            case NULL:
            	{
                alt24 = 6;
                }
                break;
            case THIS:
            	{
                alt24 = 7;
                }
                break;
            case CALLEE:
            	{
                alt24 = 8;
                }
                break;
            case LARRAY:
            	{
                alt24 = 9;
                }
                break;
            case FUNCTION:
            	{
                alt24 = 10;
                }
                break;
            case NUMBERKEYWORD:
            	{
                alt24 = 11;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return c;}
            	    NoViableAltException nvae_d24s0 =
            	        new NoViableAltException("", 24, 0, input);

            	    throw nvae_d24s0;
            }

            switch (alt24) 
            {
                case 1 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:212:4: n= NUMBER
                    {
                    	n=(IToken)Match(input,NUMBER,FOLLOW_NUMBER_in_constant1033); if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  c =  new T.NumberConstant( Double.Parse(n.Text, CultureInfo.InvariantCulture)); c.StartToken = c.EndToken = n.ToSource(); 
                    	}

                    }
                    break;
                case 2 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:213:4: s= STRINGCONST
                    {
                    	s=(IToken)Match(input,STRINGCONST,FOLLOW_STRINGCONST_in_constant1042); if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   c =  new T.StringConstant(s.Text); c.StartToken = c.EndToken = n.ToSource(); 
                    	}

                    }
                    break;
                case 3 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:214:4: ch= CHARCONST
                    {
                    	ch=(IToken)Match(input,CHARCONST,FOLLOW_CHARCONST_in_constant1051); if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  c =  new T.CharConstant(ch.Text[0]); c.StartToken = c.EndToken = ch.ToSource(); 
                    	}

                    }
                    break;
                case 4 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:215:4: tr= TRUE
                    {
                    	tr=(IToken)Match(input,TRUE,FOLLOW_TRUE_in_constant1060); if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  c =  new T.BooleanConstant(true); c.StartToken = c.EndToken = tr.ToSource(); 
                    	}

                    }
                    break;
                case 5 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:216:4: fa= FALSE
                    {
                    	fa=(IToken)Match(input,FALSE,FOLLOW_FALSE_in_constant1069); if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  c =  new T.BooleanConstant(false); c.StartToken = c.EndToken = fa.ToSource(); 
                    	}

                    }
                    break;
                case 6 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:217:4: nullToken= NULL
                    {
                    	nullToken=(IToken)Match(input,NULL,FOLLOW_NULL_in_constant1078); if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  c =  new T.NullConstant(); c.StartToken = c.EndToken = nullToken.ToSource(); 
                    	}

                    }
                    break;
                case 7 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:218:4: THIS
                    {
                    	Match(input,THIS,FOLLOW_THIS_in_constant1085); if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  c =  null; 
                    	}

                    }
                    break;
                case 8 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:219:4: CALLEE
                    {
                    	Match(input,CALLEE,FOLLOW_CALLEE_in_constant1092); if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  c =  null; 
                    	}

                    }
                    break;
                case 9 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:220:4: a= arrayconst
                    {
                    	PushFollow(FOLLOW_arrayconst_in_constant1101);
                    	a = arrayconst();
                    	state.followingStackPointer--;
                    	if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   c =  a; 
                    	}

                    }
                    break;
                case 10 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:221:4: f= functiondecl
                    {
                    	PushFollow(FOLLOW_functiondecl_in_constant1110);
                    	f = functiondecl();
                    	state.followingStackPointer--;
                    	if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  c =  f; 
                    	}

                    }
                    break;
                case 11 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:222:4: t= typeconst
                    {
                    	PushFollow(FOLLOW_typeconst_in_constant1119);
                    	t = typeconst();
                    	state.followingStackPointer--;
                    	if (state.failed) return c;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   c =  t; 
                    	}

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return c;
    }
    // $ANTLR end "constant"


    // $ANTLR start "functiondecl"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:224:1: functiondecl returns [T.Function f] : func= FUNCTION LPAREN alist= arglist RPAREN b= block ;
    public T.Function functiondecl() // throws RecognitionException [1]
    {   
        T.Function f = default(T.Function);

        IToken func = null;
        pinedl.arglist_return alist = default(pinedl.arglist_return);

        T.Block b = default(T.Block);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:224:36: (func= FUNCTION LPAREN alist= arglist RPAREN b= block )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:225:2: func= FUNCTION LPAREN alist= arglist RPAREN b= block
            {
            	func=(IToken)Match(input,FUNCTION,FOLLOW_FUNCTION_in_functiondecl1135); if (state.failed) return f;
            	if ( state.backtracking == 0 ) 
            	{
            	  f =  new T.Function(); f.StartToken = func.ToSource(); 
            	}
            	Match(input,LPAREN,FOLLOW_LPAREN_in_functiondecl1141); if (state.failed) return f;
            	PushFollow(FOLLOW_arglist_in_functiondecl1145);
            	alist = arglist();
            	state.followingStackPointer--;
            	if (state.failed) return f;
            	if ( state.backtracking == 0 ) 
            	{
            	   f.arguments = ((alist != null) ? alist.args : default(G.IList<T.FunctionArgument>)); 
            	}
            	Match(input,RPAREN,FOLLOW_RPAREN_in_functiondecl1149); if (state.failed) return f;
            	PushFollow(FOLLOW_block_in_functiondecl1154);
            	b = block();
            	state.followingStackPointer--;
            	if (state.failed) return f;
            	if ( state.backtracking == 0 ) 
            	{
            	  f.stmt=b; f.EndToken = b.EndToken; 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return f;
    }
    // $ANTLR end "functiondecl"


    // $ANTLR start "rightlist"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:231:1: rightlist returns [T.RightList r] : ( ( assignmentrightlist )=>arl= assignmentrightlist | crl= constantrightlist );
    public T.RightList rightlist() // throws RecognitionException [1]
    {   
        T.RightList r = default(T.RightList);

        T.AssignmentRightList arl = default(T.AssignmentRightList);

        pinedl.constantrightlist_return crl = default(pinedl.constantrightlist_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:231:34: ( ( assignmentrightlist )=>arl= assignmentrightlist | crl= constantrightlist )
            int alt25 = 2;
            alt25 = dfa25.Predict(input);
            switch (alt25) 
            {
                case 1 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:232:2: ( assignmentrightlist )=>arl= assignmentrightlist
                    {
                    	PushFollow(FOLLOW_assignmentrightlist_in_rightlist1178);
                    	arl = assignmentrightlist();
                    	state.followingStackPointer--;
                    	if (state.failed) return r;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   r =  arl; 
                    	}

                    }
                    break;
                case 2 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:233:2: crl= constantrightlist
                    {
                    	PushFollow(FOLLOW_constantrightlist_in_rightlist1189);
                    	crl = constantrightlist();
                    	state.followingStackPointer--;
                    	if (state.failed) return r;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	   r =  ((crl != null) ? crl.crl : default(T.ConstantRightList)); 
                    	}

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return r;
    }
    // $ANTLR end "rightlist"

    public class constantrightlist_return : ParserRuleReturnScope
    {
        public T.ConstantRightList crl;
        public object lastkey;
    };

    // $ANTLR start "constantrightlist"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:235:1: constantrightlist returns [T.ConstantRightList crl, object lastkey] : (c= crlargument[ref $lastkey] ( COMMA c2= crlargument[ref $lastkey] )* )? ;
    public pinedl.constantrightlist_return constantrightlist() // throws RecognitionException [1]
    {   
        pinedl.constantrightlist_return retval = new pinedl.constantrightlist_return();
        retval.Start = input.LT(1);

        T.Expression c = default(T.Expression);

        T.Expression c2 = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:235:68: ( (c= crlargument[ref $lastkey] ( COMMA c2= crlargument[ref $lastkey] )* )? )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:236:2: (c= crlargument[ref $lastkey] ( COMMA c2= crlargument[ref $lastkey] )* )?
            {
            	if ( state.backtracking == 0 ) 
            	{

            	  		retval.lastkey =  -1.0;
            	  		retval.crl =  new T.ConstantRightList();
            	  		retval.crl.contents = new G.Dictionary<object, T.Expression>();
            	  		retval.crl.StartToken = ((IToken) retval.Start).ToSource();
            	  	
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:242:2: (c= crlargument[ref $lastkey] ( COMMA c2= crlargument[ref $lastkey] )* )?
            	int alt27 = 2;
            	int LA27_0 = input.LA(1);

            	if ( ((LA27_0 >= FUNCTION && LA27_0 <= LPAREN) || (LA27_0 >= NUMBER && LA27_0 <= STRINGCONST) || LA27_0 == LARRAY || (LA27_0 >= NUMBERKEYWORD && LA27_0 <= CALLEE) || (LA27_0 >= INCREMENT && LA27_0 <= LOGNOT)) )
            	{
            	    alt27 = 1;
            	}
            	switch (alt27) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:242:3: c= crlargument[ref $lastkey] ( COMMA c2= crlargument[ref $lastkey] )*
            	        {
            	        	PushFollow(FOLLOW_crlargument_in_constantrightlist1210);
            	        	c = crlargument(ref retval.lastkey);
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.crl.contents[retval.lastkey] = c;
            	        	}
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:243:2: ( COMMA c2= crlargument[ref $lastkey] )*
            	        	do 
            	        	{
            	        	    int alt26 = 2;
            	        	    int LA26_0 = input.LA(1);

            	        	    if ( (LA26_0 == COMMA) )
            	        	    {
            	        	        alt26 = 1;
            	        	    }


            	        	    switch (alt26) 
            	        		{
            	        			case 1 :
            	        			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:243:3: COMMA c2= crlargument[ref $lastkey]
            	        			    {
            	        			    	Match(input,COMMA,FOLLOW_COMMA_in_constantrightlist1217); if (state.failed) return retval;
            	        			    	PushFollow(FOLLOW_crlargument_in_constantrightlist1221);
            	        			    	c2 = crlargument(ref retval.lastkey);
            	        			    	state.followingStackPointer--;
            	        			    	if (state.failed) return retval;
            	        			    	if ( state.backtracking == 0 ) 
            	        			    	{
            	        			    	  retval.crl.contents[retval.lastkey] = c2;
            	        			    	}

            	        			    }
            	        			    break;

            	        			default:
            	        			    goto loop26;
            	        	    }
            	        	} while (true);

            	        	loop26:
            	        		;	// Stops C# compiler whining that label 'loop26' has no statements


            	        }
            	        break;

            	}

            	if ( state.backtracking == 0 ) 
            	{
            	  retval.crl.EndToken = input.LT(-1).ToSource(); 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "constantrightlist"


    // $ANTLR start "assignmentrightlist"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:247:1: assignmentrightlist returns [T.AssignmentRightList rl] : als= assignmentlistleftside EQUAL vrl= rightlist ;
    public T.AssignmentRightList assignmentrightlist() // throws RecognitionException [1]
    {   
        T.AssignmentRightList rl = default(T.AssignmentRightList);

        pinedl.assignmentlistleftside_return als = default(pinedl.assignmentlistleftside_return);

        T.RightList vrl = default(T.RightList);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:247:55: (als= assignmentlistleftside EQUAL vrl= rightlist )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:248:2: als= assignmentlistleftside EQUAL vrl= rightlist
            {
            	PushFollow(FOLLOW_assignmentlistleftside_in_assignmentrightlist1247);
            	als = assignmentlistleftside();
            	state.followingStackPointer--;
            	if (state.failed) return rl;
            	Match(input,EQUAL,FOLLOW_EQUAL_in_assignmentrightlist1250); if (state.failed) return rl;
            	PushFollow(FOLLOW_rightlist_in_assignmentrightlist1254);
            	vrl = rightlist();
            	state.followingStackPointer--;
            	if (state.failed) return rl;
            	if ( state.backtracking == 0 ) 
            	{
            	  rl =  new T.AssignmentRightList(((als != null) ? als.als : default(T.AssignmentListLeftSide)), vrl); rl.StartToken = ((als != null) ? als.als : default(T.AssignmentListLeftSide)).StartToken; rl.EndToken = vrl.EndToken; 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return rl;
    }
    // $ANTLR end "assignmentrightlist"

    public class assignmentlistleftside_return : ParserRuleReturnScope
    {
        public T.AssignmentListLeftSide als;
        public object lastkey;
    };

    // $ANTLR start "assignmentlistleftside"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:253:1: assignmentlistleftside returns [T.AssignmentListLeftSide als, object lastkey] : c= alsargument[ref $lastkey] ( COMMA c2= alsargument[ref $lastkey] )* ;
    public pinedl.assignmentlistleftside_return assignmentlistleftside() // throws RecognitionException [1]
    {   
        pinedl.assignmentlistleftside_return retval = new pinedl.assignmentlistleftside_return();
        retval.Start = input.LT(1);

        T.Expression c = default(T.Expression);

        T.Expression c2 = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:253:78: (c= alsargument[ref $lastkey] ( COMMA c2= alsargument[ref $lastkey] )* )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:254:2: c= alsargument[ref $lastkey] ( COMMA c2= alsargument[ref $lastkey] )*
            {
            	if ( state.backtracking == 0 ) 
            	{

            	  		retval.lastkey =  -1.0;
            	  		retval.als =  new T.AssignmentListLeftSide();
            	  		retval.als.contents = new G.Dictionary<object, T.Expression>();
            	  		retval.als.StartToken =((IToken) retval.Start).ToSource();
            	  	
            	}
            	PushFollow(FOLLOW_alsargument_in_assignmentlistleftside1276);
            	c = alsargument(ref retval.lastkey);
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	   retval.als.contents[retval.lastkey] = c; 
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:261:2: ( COMMA c2= alsargument[ref $lastkey] )*
            	do 
            	{
            	    int alt28 = 2;
            	    int LA28_0 = input.LA(1);

            	    if ( (LA28_0 == COMMA) )
            	    {
            	        alt28 = 1;
            	    }


            	    switch (alt28) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:261:3: COMMA c2= alsargument[ref $lastkey]
            			    {
            			    	Match(input,COMMA,FOLLOW_COMMA_in_assignmentlistleftside1283); if (state.failed) return retval;
            			    	PushFollow(FOLLOW_alsargument_in_assignmentlistleftside1287);
            			    	c2 = alsargument(ref retval.lastkey);
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  retval.als.contents[retval.lastkey] = c2; 
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop28;
            	    }
            	} while (true);

            	loop28:
            		;	// Stops C# compiler whining that label 'loop28' has no statements

            	if ( state.backtracking == 0 ) 
            	{
            	   retval.als.EndToken = input.LT(-1).ToSource(); 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "assignmentlistleftside"


    // $ANTLR start "alsargument"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:265:1: alsargument[ref object lastkey] returns [T.Expression e] : ( ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON ) | ) exp= expression ;
    public T.Expression alsargument(ref object lastkey) // throws RecognitionException [1]
    {   
        T.Expression e = default(T.Expression);

        IToken w = null;
        IToken s = null;
        IToken n = null;
        T.Expression exp = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:265:58: ( ( ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON ) | ) exp= expression )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:266:2: ( ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON ) | ) exp= expression
            {
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:266:2: ( ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON ) | )
            	int alt30 = 2;
            	switch ( input.LA(1) ) 
            	{
            	case WORD:
            		{
            	    int LA30_1 = input.LA(2);

            	    if ( (LA30_1 == LPAREN || LA30_1 == COMMA || LA30_1 == EQUAL || LA30_1 == LARRAY || (LA30_1 >= DOT && LA30_1 <= MINUS) || (LA30_1 >= MULT && LA30_1 <= LOGICALOR)) )
            	    {
            	        alt30 = 2;
            	    }
            	    else if ( (LA30_1 == COLON) )
            	    {
            	        alt30 = 1;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return e;}
            	        NoViableAltException nvae_d30s1 =
            	            new NoViableAltException("", 30, 1, input);

            	        throw nvae_d30s1;
            	    }
            	    }
            	    break;
            	case STRINGCONST:
            		{
            	    int LA30_2 = input.LA(2);

            	    if ( (LA30_2 == LPAREN || LA30_2 == COMMA || LA30_2 == EQUAL || LA30_2 == LARRAY || (LA30_2 >= DOT && LA30_2 <= MINUS) || (LA30_2 >= MULT && LA30_2 <= LOGICALOR)) )
            	    {
            	        alt30 = 2;
            	    }
            	    else if ( (LA30_2 == COLON) )
            	    {
            	        alt30 = 1;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return e;}
            	        NoViableAltException nvae_d30s2 =
            	            new NoViableAltException("", 30, 2, input);

            	        throw nvae_d30s2;
            	    }
            	    }
            	    break;
            	case NUMBER:
            		{
            	    int LA30_3 = input.LA(2);

            	    if ( (LA30_3 == LPAREN || LA30_3 == COMMA || LA30_3 == EQUAL || LA30_3 == LARRAY || (LA30_3 >= DOT && LA30_3 <= MINUS) || (LA30_3 >= MULT && LA30_3 <= LOGICALOR)) )
            	    {
            	        alt30 = 2;
            	    }
            	    else if ( (LA30_3 == COLON) )
            	    {
            	        alt30 = 1;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return e;}
            	        NoViableAltException nvae_d30s3 =
            	            new NoViableAltException("", 30, 3, input);

            	        throw nvae_d30s3;
            	    }
            	    }
            	    break;
            	case FUNCTION:
            	case LPAREN:
            	case LARRAY:
            	case NUMBERKEYWORD:
            	case CHARCONST:
            	case TRUE:
            	case FALSE:
            	case NULL:
            	case THIS:
            	case CALLEE:
            	case INCREMENT:
            	case DECREMENT:
            	case PLUS:
            	case MINUS:
            	case BITNOT:
            	case LOGNOT:
            		{
            	    alt30 = 2;
            	    }
            	    break;
            		default:
            		    if ( state.backtracking > 0 ) {state.failed = true; return e;}
            		    NoViableAltException nvae_d30s0 =
            		        new NoViableAltException("", 30, 0, input);

            		    throw nvae_d30s0;
            	}

            	switch (alt30) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:266:3: ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON )
            	        {
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:266:3: ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON )
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:266:4: (w= WORD | s= STRINGCONST | n= NUMBER ) COLON
            	        	{
            	        		// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:266:4: (w= WORD | s= STRINGCONST | n= NUMBER )
            	        		int alt29 = 3;
            	        		switch ( input.LA(1) ) 
            	        		{
            	        		case WORD:
            	        			{
            	        		    alt29 = 1;
            	        		    }
            	        		    break;
            	        		case STRINGCONST:
            	        			{
            	        		    alt29 = 2;
            	        		    }
            	        		    break;
            	        		case NUMBER:
            	        			{
            	        		    alt29 = 3;
            	        		    }
            	        		    break;
            	        			default:
            	        			    if ( state.backtracking > 0 ) {state.failed = true; return e;}
            	        			    NoViableAltException nvae_d29s0 =
            	        			        new NoViableAltException("", 29, 0, input);

            	        			    throw nvae_d29s0;
            	        		}

            	        		switch (alt29) 
            	        		{
            	        		    case 1 :
            	        		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:266:5: w= WORD
            	        		        {
            	        		        	w=(IToken)Match(input,WORD,FOLLOW_WORD_in_alsargument1316); if (state.failed) return e;
            	        		        	if ( state.backtracking == 0 ) 
            	        		        	{
            	        		        	  lastkey =  w.Text;
            	        		        	}

            	        		        }
            	        		        break;
            	        		    case 2 :
            	        		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:266:33: s= STRINGCONST
            	        		        {
            	        		        	s=(IToken)Match(input,STRINGCONST,FOLLOW_STRINGCONST_in_alsargument1322); if (state.failed) return e;
            	        		        	if ( state.backtracking == 0 ) 
            	        		        	{
            	        		        	  lastkey = s.Text;
            	        		        	}

            	        		        }
            	        		        break;
            	        		    case 3 :
            	        		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:266:66: n= NUMBER
            	        		        {
            	        		        	n=(IToken)Match(input,NUMBER,FOLLOW_NUMBER_in_alsargument1327); if (state.failed) return e;
            	        		        	if ( state.backtracking == 0 ) 
            	        		        	{
            	        		        	  lastkey = Double.Parse(n.Text, CultureInfo.InvariantCulture);
            	        		        	}

            	        		        }
            	        		        break;

            	        		}

            	        		Match(input,COLON,FOLLOW_COLON_in_alsargument1332); if (state.failed) return e;

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:267:4: 
            	        {
            	        	if ( state.backtracking == 0 ) 
            	        	{

            	        	  	if (!(lastkey is double))
            	        	  		throw new Exception("Could not guess list key");
            	        	  	lastkey =  ((double) lastkey) + 1;
            	        	  	
            	        	}

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_expression_in_alsargument1344);
            	exp = expression();
            	state.followingStackPointer--;
            	if (state.failed) return e;
            	if ( state.backtracking == 0 ) 
            	{
            	  e =  exp; 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return e;
    }
    // $ANTLR end "alsargument"

    public class declarationlist_return : ParserRuleReturnScope
    {
        public T.VariableDeclarationLeftList list;
        public bool isConst;
        public object key;
    };

    // $ANTLR start "declarationlist"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:275:1: declarationlist returns [T.VariableDeclarationLeftList list, bool isConst, object key] : ( VAR | CONST ) ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON )? name= WORD ;
    public pinedl.declarationlist_return declarationlist() // throws RecognitionException [1]
    {   
        pinedl.declarationlist_return retval = new pinedl.declarationlist_return();
        retval.Start = input.LT(1);

        IToken w = null;
        IToken s = null;
        IToken n = null;
        IToken name = null;

        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:276:2: ( ( VAR | CONST ) ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON )? name= WORD )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:277:2: ( VAR | CONST ) ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON )? name= WORD
            {
            	if ( state.backtracking == 0 ) 
            	{

            	  		retval.list =  new T.VariableDeclarationLeftList();
            	  		retval.key =  0.0;
            	  		retval.isConst =  false;
            	  		retval.list.StartToken = ((IToken) retval.Start).ToSource();
            	  	
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:283:2: ( VAR | CONST )
            	int alt31 = 2;
            	int LA31_0 = input.LA(1);

            	if ( (LA31_0 == VAR) )
            	{
            	    alt31 = 1;
            	}
            	else if ( (LA31_0 == CONST) )
            	{
            	    alt31 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d31s0 =
            	        new NoViableAltException("", 31, 0, input);

            	    throw nvae_d31s0;
            	}
            	switch (alt31) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:283:3: VAR
            	        {
            	        	Match(input,VAR,FOLLOW_VAR_in_declarationlist1366); if (state.failed) return retval;

            	        }
            	        break;
            	    case 2 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:283:9: CONST
            	        {
            	        	Match(input,CONST,FOLLOW_CONST_in_declarationlist1370); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.isConst =  true;
            	        	}

            	        }
            	        break;

            	}

            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:284:2: ( (w= WORD | s= STRINGCONST | n= NUMBER ) COLON )?
            	int alt33 = 2;
            	int LA33_0 = input.LA(1);

            	if ( (LA33_0 == WORD) )
            	{
            	    int LA33_1 = input.LA(2);

            	    if ( (LA33_1 == COLON) )
            	    {
            	        alt33 = 1;
            	    }
            	}
            	else if ( ((LA33_0 >= NUMBER && LA33_0 <= STRINGCONST)) )
            	{
            	    alt33 = 1;
            	}
            	switch (alt33) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:284:3: (w= WORD | s= STRINGCONST | n= NUMBER ) COLON
            	        {
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:284:3: (w= WORD | s= STRINGCONST | n= NUMBER )
            	        	int alt32 = 3;
            	        	switch ( input.LA(1) ) 
            	        	{
            	        	case WORD:
            	        		{
            	        	    alt32 = 1;
            	        	    }
            	        	    break;
            	        	case STRINGCONST:
            	        		{
            	        	    alt32 = 2;
            	        	    }
            	        	    break;
            	        	case NUMBER:
            	        		{
            	        	    alt32 = 3;
            	        	    }
            	        	    break;
            	        		default:
            	        		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        		    NoViableAltException nvae_d32s0 =
            	        		        new NoViableAltException("", 32, 0, input);

            	        		    throw nvae_d32s0;
            	        	}

            	        	switch (alt32) 
            	        	{
            	        	    case 1 :
            	        	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:284:4: w= WORD
            	        	        {
            	        	        	w=(IToken)Match(input,WORD,FOLLOW_WORD_in_declarationlist1380); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) 
            	        	        	{
            	        	        	  retval.key = w.Text;
            	        	        	}

            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:284:27: s= STRINGCONST
            	        	        {
            	        	        	s=(IToken)Match(input,STRINGCONST,FOLLOW_STRINGCONST_in_declarationlist1386); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) 
            	        	        	{
            	        	        	  retval.key = s.Text;
            	        	        	}

            	        	        }
            	        	        break;
            	        	    case 3 :
            	        	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:284:57: n= NUMBER
            	        	        {
            	        	        	n=(IToken)Match(input,NUMBER,FOLLOW_NUMBER_in_declarationlist1392); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) 
            	        	        	{
            	        	        	  retval.key = Double.Parse(n.Text, CultureInfo.InvariantCulture);
            	        	        	}

            	        	        }
            	        	        break;

            	        	}

            	        	Match(input,COLON,FOLLOW_COLON_in_declarationlist1397); if (state.failed) return retval;

            	        }
            	        break;

            	}

            	name=(IToken)Match(input,WORD,FOLLOW_WORD_in_declarationlist1404); if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{

            	  		var decl = new T.VariableDeclarationElement(retval.isConst, retval.key, name.Text, false);
            	  		retval.list.declarations.Add(decl);
            	  	
            	}
            	if ( state.backtracking == 0 ) 
            	{
            	   retval.list.EndToken = input.LT(-1).ToSource(); 
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "declarationlist"

    public class declarationstmt_return : ParserRuleReturnScope
    {
        public T.DeclarationStatement stmt;
        public T.RightList rl;
    };

    // $ANTLR start "declarationstmt"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:296:1: declarationstmt returns [T.DeclarationStatement stmt, T.RightList rl] : l= declarationlist ( EQUAL r= rightlist )? ;
    public pinedl.declarationstmt_return declarationstmt() // throws RecognitionException [1]
    {   
        pinedl.declarationstmt_return retval = new pinedl.declarationstmt_return();
        retval.Start = input.LT(1);

        pinedl.declarationlist_return l = default(pinedl.declarationlist_return);

        T.RightList r = default(T.RightList);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:297:2: (l= declarationlist ( EQUAL r= rightlist )? )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:298:2: l= declarationlist ( EQUAL r= rightlist )?
            {
            	PushFollow(FOLLOW_declarationlist_in_declarationstmt1434);
            	l = declarationlist();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:299:2: ( EQUAL r= rightlist )?
            	int alt34 = 2;
            	int LA34_0 = input.LA(1);

            	if ( (LA34_0 == EQUAL) )
            	{
            	    alt34 = 1;
            	}
            	switch (alt34) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:299:3: EQUAL r= rightlist
            	        {
            	        	Match(input,EQUAL,FOLLOW_EQUAL_in_declarationstmt1438); if (state.failed) return retval;
            	        	PushFollow(FOLLOW_rightlist_in_declarationstmt1442);
            	        	r = rightlist();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.rl = r;
            	        	}

            	        }
            	        break;

            	}

            	if ( state.backtracking == 0 ) 
            	{

            	  		retval.stmt =  new T.DeclarationStatement(((l != null) ? l.list : default(T.VariableDeclarationLeftList)), retval.rl);
            	  		retval.stmt.StartToken = ((l != null) ? l.list : default(T.VariableDeclarationLeftList)).StartToken;
            	  		retval.stmt.EndToken = input.LT(-1).ToSource();
            	  	
            	}

            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "declarationstmt"


    // $ANTLR start "crlargument"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:307:1: crlargument[ref object lastkey] returns [T.Expression e] : ( ( (w= WORD | x= STRINGCONST | n= NUMBER ) COLON ) | ) exp= expression ;
    public T.Expression crlargument(ref object lastkey) // throws RecognitionException [1]
    {   
        T.Expression e = default(T.Expression);

        IToken w = null;
        IToken x = null;
        IToken n = null;
        T.Expression exp = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:307:58: ( ( ( (w= WORD | x= STRINGCONST | n= NUMBER ) COLON ) | ) exp= expression )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:308:2: ( ( (w= WORD | x= STRINGCONST | n= NUMBER ) COLON ) | ) exp= expression
            {
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:308:2: ( ( (w= WORD | x= STRINGCONST | n= NUMBER ) COLON ) | )
            	int alt36 = 2;
            	switch ( input.LA(1) ) 
            	{
            	case WORD:
            		{
            	    int LA36_1 = input.LA(2);

            	    if ( (LA36_1 == EOF || (LA36_1 >= LPAREN && LA36_1 <= COMMA) || LA36_1 == SEMICOLON || LA36_1 == LARRAY || (LA36_1 >= DOT && LA36_1 <= MINUS) || (LA36_1 >= MULT && LA36_1 <= LOGICALOR)) )
            	    {
            	        alt36 = 2;
            	    }
            	    else if ( (LA36_1 == COLON) )
            	    {
            	        alt36 = 1;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return e;}
            	        NoViableAltException nvae_d36s1 =
            	            new NoViableAltException("", 36, 1, input);

            	        throw nvae_d36s1;
            	    }
            	    }
            	    break;
            	case STRINGCONST:
            		{
            	    int LA36_2 = input.LA(2);

            	    if ( (LA36_2 == COLON) )
            	    {
            	        alt36 = 1;
            	    }
            	    else if ( (LA36_2 == EOF || (LA36_2 >= LPAREN && LA36_2 <= COMMA) || LA36_2 == SEMICOLON || LA36_2 == LARRAY || (LA36_2 >= DOT && LA36_2 <= MINUS) || (LA36_2 >= MULT && LA36_2 <= LOGICALOR)) )
            	    {
            	        alt36 = 2;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return e;}
            	        NoViableAltException nvae_d36s2 =
            	            new NoViableAltException("", 36, 2, input);

            	        throw nvae_d36s2;
            	    }
            	    }
            	    break;
            	case NUMBER:
            		{
            	    int LA36_3 = input.LA(2);

            	    if ( (LA36_3 == COLON) )
            	    {
            	        alt36 = 1;
            	    }
            	    else if ( (LA36_3 == EOF || (LA36_3 >= LPAREN && LA36_3 <= COMMA) || LA36_3 == SEMICOLON || LA36_3 == LARRAY || (LA36_3 >= DOT && LA36_3 <= MINUS) || (LA36_3 >= MULT && LA36_3 <= LOGICALOR)) )
            	    {
            	        alt36 = 2;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return e;}
            	        NoViableAltException nvae_d36s3 =
            	            new NoViableAltException("", 36, 3, input);

            	        throw nvae_d36s3;
            	    }
            	    }
            	    break;
            	case FUNCTION:
            	case LPAREN:
            	case LARRAY:
            	case NUMBERKEYWORD:
            	case CHARCONST:
            	case TRUE:
            	case FALSE:
            	case NULL:
            	case THIS:
            	case CALLEE:
            	case INCREMENT:
            	case DECREMENT:
            	case PLUS:
            	case MINUS:
            	case BITNOT:
            	case LOGNOT:
            		{
            	    alt36 = 2;
            	    }
            	    break;
            		default:
            		    if ( state.backtracking > 0 ) {state.failed = true; return e;}
            		    NoViableAltException nvae_d36s0 =
            		        new NoViableAltException("", 36, 0, input);

            		    throw nvae_d36s0;
            	}

            	switch (alt36) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:308:3: ( (w= WORD | x= STRINGCONST | n= NUMBER ) COLON )
            	        {
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:308:3: ( (w= WORD | x= STRINGCONST | n= NUMBER ) COLON )
            	        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:308:4: (w= WORD | x= STRINGCONST | n= NUMBER ) COLON
            	        	{
            	        		// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:308:4: (w= WORD | x= STRINGCONST | n= NUMBER )
            	        		int alt35 = 3;
            	        		switch ( input.LA(1) ) 
            	        		{
            	        		case WORD:
            	        			{
            	        		    alt35 = 1;
            	        		    }
            	        		    break;
            	        		case STRINGCONST:
            	        			{
            	        		    alt35 = 2;
            	        		    }
            	        		    break;
            	        		case NUMBER:
            	        			{
            	        		    alt35 = 3;
            	        		    }
            	        		    break;
            	        			default:
            	        			    if ( state.backtracking > 0 ) {state.failed = true; return e;}
            	        			    NoViableAltException nvae_d35s0 =
            	        			        new NoViableAltException("", 35, 0, input);

            	        			    throw nvae_d35s0;
            	        		}

            	        		switch (alt35) 
            	        		{
            	        		    case 1 :
            	        		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:308:5: w= WORD
            	        		        {
            	        		        	w=(IToken)Match(input,WORD,FOLLOW_WORD_in_crlargument1470); if (state.failed) return e;
            	        		        	if ( state.backtracking == 0 ) 
            	        		        	{
            	        		        	  lastkey = w.Text;
            	        		        	}

            	        		        }
            	        		        break;
            	        		    case 2 :
            	        		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:308:32: x= STRINGCONST
            	        		        {
            	        		        	x=(IToken)Match(input,STRINGCONST,FOLLOW_STRINGCONST_in_crlargument1476); if (state.failed) return e;
            	        		        	if ( state.backtracking == 0 ) 
            	        		        	{
            	        		        	  lastkey=x.Text;
            	        		        	}

            	        		        }
            	        		        break;
            	        		    case 3 :
            	        		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:308:65: n= NUMBER
            	        		        {
            	        		        	n=(IToken)Match(input,NUMBER,FOLLOW_NUMBER_in_crlargument1482); if (state.failed) return e;
            	        		        	if ( state.backtracking == 0 ) 
            	        		        	{
            	        		        	  lastkey=Double.Parse(n.Text, CultureInfo.InvariantCulture);
            	        		        	}

            	        		        }
            	        		        break;

            	        		}

            	        		Match(input,COLON,FOLLOW_COLON_in_crlargument1487); if (state.failed) return e;

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:309:4: 
            	        {
            	        	if ( state.backtracking == 0 ) 
            	        	{

            	        	  	if(!(lastkey is double))
            	        	  		throw new Exception("Could not guess list key");
            	        	  	lastkey =  ((double) lastkey) + 1;
            	        	  	
            	        	}

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_expression_in_crlargument1498);
            	exp = expression();
            	state.followingStackPointer--;
            	if (state.failed) return e;
            	if ( state.backtracking == 0 ) 
            	{
            	  e = exp;
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return e;
    }
    // $ANTLR end "crlargument"

    public class atom_return : ParserRuleReturnScope
    {
        public T.Expression e;
        public Antlr.Runtime.IToken start;
    };

    // $ANTLR start "atom"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:316:1: atom returns [T.Expression e, Antlr.Runtime.IToken start] : (c= constant | i= WORD | left= LPAREN r= rightlist right= RPAREN ) ( ( DOT f= WORD ) | ( LPAREN r= rightlist right= RPAREN ) | ( LARRAY idx= expression right= RARRAY ) )* ;
    public pinedl.atom_return atom() // throws RecognitionException [1]
    {   
        pinedl.atom_return retval = new pinedl.atom_return();
        retval.Start = input.LT(1);

        IToken i = null;
        IToken left = null;
        IToken right = null;
        IToken f = null;
        T.Constant c = default(T.Constant);

        T.RightList r = default(T.RightList);

        T.Expression idx = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:316:58: ( (c= constant | i= WORD | left= LPAREN r= rightlist right= RPAREN ) ( ( DOT f= WORD ) | ( LPAREN r= rightlist right= RPAREN ) | ( LARRAY idx= expression right= RARRAY ) )* )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:317:2: (c= constant | i= WORD | left= LPAREN r= rightlist right= RPAREN ) ( ( DOT f= WORD ) | ( LPAREN r= rightlist right= RPAREN ) | ( LARRAY idx= expression right= RARRAY ) )*
            {
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:317:2: (c= constant | i= WORD | left= LPAREN r= rightlist right= RPAREN )
            	int alt37 = 3;
            	switch ( input.LA(1) ) 
            	{
            	case FUNCTION:
            	case NUMBER:
            	case STRINGCONST:
            	case LARRAY:
            	case NUMBERKEYWORD:
            	case CHARCONST:
            	case TRUE:
            	case FALSE:
            	case NULL:
            	case THIS:
            	case CALLEE:
            		{
            	    alt37 = 1;
            	    }
            	    break;
            	case WORD:
            		{
            	    alt37 = 2;
            	    }
            	    break;
            	case LPAREN:
            		{
            	    alt37 = 3;
            	    }
            	    break;
            		default:
            		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		    NoViableAltException nvae_d37s0 =
            		        new NoViableAltException("", 37, 0, input);

            		    throw nvae_d37s0;
            	}

            	switch (alt37) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:317:3: c= constant
            	        {
            	        	PushFollow(FOLLOW_constant_in_atom1516);
            	        	c = constant();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.e =  c; retval.start =  input.LT(1); 
            	        	}

            	        }
            	        break;
            	    case 2 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:318:4: i= WORD
            	        {
            	        	i=(IToken)Match(input,WORD,FOLLOW_WORD_in_atom1525); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.e =  new T.NameIdentifier(i.Text); retval.e.StartToken = retval.e.EndToken = i.ToSource(); 
            	        	}

            	        }
            	        break;
            	    case 3 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:319:4: left= LPAREN r= rightlist right= RPAREN
            	        {
            	        	left=(IToken)Match(input,LPAREN,FOLLOW_LPAREN_in_atom1534); if (state.failed) return retval;
            	        	PushFollow(FOLLOW_rightlist_in_atom1538);
            	        	r = rightlist();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	right=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_atom1542); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  retval.e =  new T.ListCompression(r); retval.e.StartToken = left.ToSource(); retval.e.EndToken = right.ToSource(); 
            	        	}

            	        }
            	        break;

            	}

            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:321:2: ( ( DOT f= WORD ) | ( LPAREN r= rightlist right= RPAREN ) | ( LARRAY idx= expression right= RARRAY ) )*
            	do 
            	{
            	    int alt38 = 4;
            	    switch ( input.LA(1) ) 
            	    {
            	    case DOT:
            	    	{
            	        alt38 = 1;
            	        }
            	        break;
            	    case LPAREN:
            	    	{
            	        alt38 = 2;
            	        }
            	        break;
            	    case LARRAY:
            	    	{
            	        alt38 = 3;
            	        }
            	        break;

            	    }

            	    switch (alt38) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:321:3: ( DOT f= WORD )
            			    {
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:321:3: ( DOT f= WORD )
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:321:4: DOT f= WORD
            			    	{
            			    		Match(input,DOT,FOLLOW_DOT_in_atom1552); if (state.failed) return retval;
            			    		f=(IToken)Match(input,WORD,FOLLOW_WORD_in_atom1556); if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) 
            			    		{
            			    		  retval.e =  new T.FieldReference(retval.e, f.Text); retval.e.StartToken = retval.start.ToSource(); retval.e.EndToken = f.ToSource(); 
            			    		}

            			    	}


            			    }
            			    break;
            			case 2 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:322:4: ( LPAREN r= rightlist right= RPAREN )
            			    {
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:322:4: ( LPAREN r= rightlist right= RPAREN )
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:322:5: LPAREN r= rightlist right= RPAREN
            			    	{
            			    		Match(input,LPAREN,FOLLOW_LPAREN_in_atom1565); if (state.failed) return retval;
            			    		PushFollow(FOLLOW_rightlist_in_atom1569);
            			    		r = rightlist();
            			    		state.followingStackPointer--;
            			    		if (state.failed) return retval;
            			    		right=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_atom1573); if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) 
            			    		{
            			    		  retval.e =  new T.CallExpression(retval.e, r); retval.e.StartToken = retval.start.ToSource(); retval.e.EndToken = right.ToSource(); 
            			    		}

            			    	}


            			    }
            			    break;
            			case 3 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:323:4: ( LARRAY idx= expression right= RARRAY )
            			    {
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:323:4: ( LARRAY idx= expression right= RARRAY )
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:323:5: LARRAY idx= expression right= RARRAY
            			    	{
            			    		Match(input,LARRAY,FOLLOW_LARRAY_in_atom1582); if (state.failed) return retval;
            			    		PushFollow(FOLLOW_expression_in_atom1586);
            			    		idx = expression();
            			    		state.followingStackPointer--;
            			    		if (state.failed) return retval;
            			    		right=(IToken)Match(input,RARRAY,FOLLOW_RARRAY_in_atom1590); if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) 
            			    		{
            			    		  retval.e =  new T.ArrayAccessExpression(retval.e, idx); retval.e.StartToken = retval.start.ToSource(); retval.e.EndToken = right.ToSource(); 
            			    		}

            			    	}


            			    }
            			    break;

            			default:
            			    goto loop38;
            	    }
            	} while (true);

            	loop38:
            		;	// Stops C# compiler whining that label 'loop38' has no statements


            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "atom"


    // $ANTLR start "pfix"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:327:1: pfix returns [T.Expression e] : b= atom ( INCREMENT | DECREMENT )? ;
    public T.Expression pfix() // throws RecognitionException [1]
    {   
        T.Expression e = default(T.Expression);

        pinedl.atom_return b = default(pinedl.atom_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:327:30: (b= atom ( INCREMENT | DECREMENT )? )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:328:2: b= atom ( INCREMENT | DECREMENT )?
            {
            	PushFollow(FOLLOW_atom_in_pfix1613);
            	b = atom();
            	state.followingStackPointer--;
            	if (state.failed) return e;
            	if ( state.backtracking == 0 ) 
            	{
            	  e =  ((b != null) ? b.e : default(T.Expression));
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:329:2: ( INCREMENT | DECREMENT )?
            	int alt39 = 3;
            	int LA39_0 = input.LA(1);

            	if ( (LA39_0 == INCREMENT) )
            	{
            	    alt39 = 1;
            	}
            	else if ( (LA39_0 == DECREMENT) )
            	{
            	    alt39 = 2;
            	}
            	switch (alt39) 
            	{
            	    case 1 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:329:3: INCREMENT
            	        {
            	        	Match(input,INCREMENT,FOLLOW_INCREMENT_in_pfix1619); if (state.failed) return e;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  e =  new T.PostfixExpression(e, true);
            	        	}

            	        }
            	        break;
            	    case 2 :
            	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:329:57: DECREMENT
            	        {
            	        	Match(input,DECREMENT,FOLLOW_DECREMENT_in_pfix1625); if (state.failed) return e;
            	        	if ( state.backtracking == 0 ) 
            	        	{
            	        	  e =  new T.PostfixExpression(e, false);
            	        	}

            	        }
            	        break;

            	}

            	if ( state.backtracking == 0 ) 
            	{
            	  e.StartToken = ((b != null) ? b.e : default(T.Expression)).StartToken; e.EndToken = input.LT(-1).ToSource(); 
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return e;
    }
    // $ANTLR end "pfix"

    public class unary_return : ParserRuleReturnScope
    {
        public T.Expression e;
        public T.UnaryExpressionType type;
    };

    // $ANTLR start "unary"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:333:1: unary returns [T.Expression e, T.UnaryExpressionType type] : (p= pfix | ( ( INCREMENT | DECREMENT | PLUS | MINUS | BITNOT | LOGNOT ) f= pfix ) );
    public pinedl.unary_return unary() // throws RecognitionException [1]
    {   
        pinedl.unary_return retval = new pinedl.unary_return();
        retval.Start = input.LT(1);

        T.Expression p = default(T.Expression);

        T.Expression f = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:333:59: (p= pfix | ( ( INCREMENT | DECREMENT | PLUS | MINUS | BITNOT | LOGNOT ) f= pfix ) )
            int alt41 = 2;
            int LA41_0 = input.LA(1);

            if ( ((LA41_0 >= FUNCTION && LA41_0 <= LPAREN) || (LA41_0 >= NUMBER && LA41_0 <= STRINGCONST) || LA41_0 == LARRAY || (LA41_0 >= NUMBERKEYWORD && LA41_0 <= CALLEE)) )
            {
                alt41 = 1;
            }
            else if ( ((LA41_0 >= INCREMENT && LA41_0 <= LOGNOT)) )
            {
                alt41 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d41s0 =
                    new NoViableAltException("", 41, 0, input);

                throw nvae_d41s0;
            }
            switch (alt41) 
            {
                case 1 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:334:2: p= pfix
                    {
                    	PushFollow(FOLLOW_pfix_in_unary1648);
                    	p = pfix();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  retval.e =  p;
                    	}

                    }
                    break;
                case 2 :
                    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:335:3: ( ( INCREMENT | DECREMENT | PLUS | MINUS | BITNOT | LOGNOT ) f= pfix )
                    {
                    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:335:3: ( ( INCREMENT | DECREMENT | PLUS | MINUS | BITNOT | LOGNOT ) f= pfix )
                    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:336:2: ( INCREMENT | DECREMENT | PLUS | MINUS | BITNOT | LOGNOT ) f= pfix
                    	{
                    		// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:336:2: ( INCREMENT | DECREMENT | PLUS | MINUS | BITNOT | LOGNOT )
                    		int alt40 = 6;
                    		switch ( input.LA(1) ) 
                    		{
                    		case INCREMENT:
                    			{
                    		    alt40 = 1;
                    		    }
                    		    break;
                    		case DECREMENT:
                    			{
                    		    alt40 = 2;
                    		    }
                    		    break;
                    		case PLUS:
                    			{
                    		    alt40 = 3;
                    		    }
                    		    break;
                    		case MINUS:
                    			{
                    		    alt40 = 4;
                    		    }
                    		    break;
                    		case BITNOT:
                    			{
                    		    alt40 = 5;
                    		    }
                    		    break;
                    		case LOGNOT:
                    			{
                    		    alt40 = 6;
                    		    }
                    		    break;
                    			default:
                    			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    			    NoViableAltException nvae_d40s0 =
                    			        new NoViableAltException("", 40, 0, input);

                    			    throw nvae_d40s0;
                    		}

                    		switch (alt40) 
                    		{
                    		    case 1 :
                    		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:337:2: INCREMENT
                    		        {
                    		        	Match(input,INCREMENT,FOLLOW_INCREMENT_in_unary1660); if (state.failed) return retval;
                    		        	if ( state.backtracking == 0 ) 
                    		        	{
                    		        	  retval.type =  T.UnaryExpressionType.Increment;
                    		        	}

                    		        }
                    		        break;
                    		    case 2 :
                    		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:338:3: DECREMENT
                    		        {
                    		        	Match(input,DECREMENT,FOLLOW_DECREMENT_in_unary1666); if (state.failed) return retval;
                    		        	if ( state.backtracking == 0 ) 
                    		        	{
                    		        	  retval.type =  T.UnaryExpressionType.Decrement;
                    		        	}

                    		        }
                    		        break;
                    		    case 3 :
                    		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:339:3: PLUS
                    		        {
                    		        	Match(input,PLUS,FOLLOW_PLUS_in_unary1672); if (state.failed) return retval;
                    		        	if ( state.backtracking == 0 ) 
                    		        	{
                    		        	  retval.type =  T.UnaryExpressionType.Positive;
                    		        	}

                    		        }
                    		        break;
                    		    case 4 :
                    		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:340:3: MINUS
                    		        {
                    		        	Match(input,MINUS,FOLLOW_MINUS_in_unary1678); if (state.failed) return retval;
                    		        	if ( state.backtracking == 0 ) 
                    		        	{
                    		        	  retval.type =  T.UnaryExpressionType.Negative;
                    		        	}

                    		        }
                    		        break;
                    		    case 5 :
                    		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:341:3: BITNOT
                    		        {
                    		        	Match(input,BITNOT,FOLLOW_BITNOT_in_unary1684); if (state.failed) return retval;
                    		        	if ( state.backtracking == 0 ) 
                    		        	{
                    		        	  retval.type =  T.UnaryExpressionType.BinaryNegation;
                    		        	}

                    		        }
                    		        break;
                    		    case 6 :
                    		        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:342:3: LOGNOT
                    		        {
                    		        	Match(input,LOGNOT,FOLLOW_LOGNOT_in_unary1690); if (state.failed) return retval;
                    		        	if ( state.backtracking == 0 ) 
                    		        	{
                    		        	  retval.type =  T.UnaryExpressionType.LogicalNegation;
                    		        	}

                    		        }
                    		        break;

                    		}

                    		PushFollow(FOLLOW_pfix_in_unary1698);
                    		f = pfix();
                    		state.followingStackPointer--;
                    		if (state.failed) return retval;
                    		if ( state.backtracking == 0 ) 
                    		{
                    		  retval.e =  new T.UnaryExpression(f, retval.type); retval.e.StartToken = ((IToken) retval.Start).ToSource(); retval.e.EndToken = f.EndToken; 
                    		}

                    	}


                    }
                    break;

            }
            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "unary"

    public class mult_return : ParserRuleReturnScope
    {
        public T.Expression e;
        public T.OperationType type;
    };

    // $ANTLR start "mult"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:345:1: mult returns [T.Expression e, T.OperationType type] : a1= unary ( ( MULT ) a2= unary )* ;
    public pinedl.mult_return mult() // throws RecognitionException [1]
    {   
        pinedl.mult_return retval = new pinedl.mult_return();
        retval.Start = input.LT(1);

        pinedl.unary_return a1 = default(pinedl.unary_return);

        pinedl.unary_return a2 = default(pinedl.unary_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:345:52: (a1= unary ( ( MULT ) a2= unary )* )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:346:2: a1= unary ( ( MULT ) a2= unary )*
            {
            	PushFollow(FOLLOW_unary_in_mult1715);
            	a1 = unary();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.e =  ((a1 != null) ? a1.e : default(T.Expression));
            	}
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.type =  default(T.OperationType);
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:348:2: ( ( MULT ) a2= unary )*
            	do 
            	{
            	    int alt42 = 2;
            	    int LA42_0 = input.LA(1);

            	    if ( (LA42_0 == MULT) )
            	    {
            	        alt42 = 1;
            	    }


            	    switch (alt42) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:348:3: ( MULT ) a2= unary
            			    {
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:348:3: ( MULT )
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:348:4: MULT
            			    	{
            			    		Match(input,MULT,FOLLOW_MULT_in_mult1725); if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) 
            			    		{
            			    		   retval.type =  T.OperationType.Multiplication; 
            			    		}

            			    	}

            			    	PushFollow(FOLLOW_unary_in_mult1733);
            			    	a2 = unary();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  retval.e =  new T.BinaryOperation(retval.type, retval.e, ((a2 != null) ? a2.e : default(T.Expression))); retval.e.StartToken = ((a1 != null) ? a1.e : default(T.Expression)).StartToken; retval.e.EndToken = input.LT(-1).ToSource(); 
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop42;
            	    }
            	} while (true);

            	loop42:
            		;	// Stops C# compiler whining that label 'loop42' has no statements


            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "mult"

    public class plus_return : ParserRuleReturnScope
    {
        public T.Expression e;
        public T.OperationType type;
    };

    // $ANTLR start "plus"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:352:1: plus returns [T.Expression e, T.OperationType type] : a1= mult ( ( PLUS | MINUS ) a2= mult )* ;
    public pinedl.plus_return plus() // throws RecognitionException [1]
    {   
        pinedl.plus_return retval = new pinedl.plus_return();
        retval.Start = input.LT(1);

        pinedl.mult_return a1 = default(pinedl.mult_return);

        pinedl.mult_return a2 = default(pinedl.mult_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:352:52: (a1= mult ( ( PLUS | MINUS ) a2= mult )* )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:353:2: a1= mult ( ( PLUS | MINUS ) a2= mult )*
            {
            	PushFollow(FOLLOW_mult_in_plus1753);
            	a1 = mult();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.e =  ((a1 != null) ? a1.e : default(T.Expression));
            	}
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.type =  default(T.OperationType);
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:355:2: ( ( PLUS | MINUS ) a2= mult )*
            	do 
            	{
            	    int alt44 = 2;
            	    int LA44_0 = input.LA(1);

            	    if ( ((LA44_0 >= PLUS && LA44_0 <= MINUS)) )
            	    {
            	        alt44 = 1;
            	    }


            	    switch (alt44) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:355:3: ( PLUS | MINUS ) a2= mult
            			    {
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:355:3: ( PLUS | MINUS )
            			    	int alt43 = 2;
            			    	int LA43_0 = input.LA(1);

            			    	if ( (LA43_0 == PLUS) )
            			    	{
            			    	    alt43 = 1;
            			    	}
            			    	else if ( (LA43_0 == MINUS) )
            			    	{
            			    	    alt43 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d43s0 =
            			    	        new NoViableAltException("", 43, 0, input);

            			    	    throw nvae_d43s0;
            			    	}
            			    	switch (alt43) 
            			    	{
            			    	    case 1 :
            			    	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:355:4: PLUS
            			    	        {
            			    	        	Match(input,PLUS,FOLLOW_PLUS_in_plus1763); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	   retval.type =  T.OperationType.Sum; 
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:355:44: MINUS
            			    	        {
            			    	        	Match(input,MINUS,FOLLOW_MINUS_in_plus1769); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	  retval.type =  T.OperationType.Minus; 
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_mult_in_plus1777);
            			    	a2 = mult();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  retval.e =  new T.BinaryOperation(retval.type, retval.e, ((a2 != null) ? a2.e : default(T.Expression))); retval.e.StartToken = ((a1 != null) ? a1.e : default(T.Expression)).StartToken; retval.e.EndToken = ((a2 != null) ? a2.e : default(T.Expression)).EndToken; 
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop44;
            	    }
            	} while (true);

            	loop44:
            		;	// Stops C# compiler whining that label 'loop44' has no statements


            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "plus"

    public class compare_return : ParserRuleReturnScope
    {
        public T.Expression e;
        public T.OperationType type;
    };

    // $ANTLR start "compare"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:359:1: compare returns [T.Expression e, T.OperationType type] : a1= plus ( ( LESS | LESSOREQUAL | GREATER | GREATEROREQUAL ) a2= plus )* ;
    public pinedl.compare_return compare() // throws RecognitionException [1]
    {   
        pinedl.compare_return retval = new pinedl.compare_return();
        retval.Start = input.LT(1);

        pinedl.plus_return a1 = default(pinedl.plus_return);

        pinedl.plus_return a2 = default(pinedl.plus_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:359:55: (a1= plus ( ( LESS | LESSOREQUAL | GREATER | GREATEROREQUAL ) a2= plus )* )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:360:2: a1= plus ( ( LESS | LESSOREQUAL | GREATER | GREATEROREQUAL ) a2= plus )*
            {
            	PushFollow(FOLLOW_plus_in_compare1797);
            	a1 = plus();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.e =  ((a1 != null) ? a1.e : default(T.Expression));
            	}
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.type =  default(T.OperationType);
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:362:2: ( ( LESS | LESSOREQUAL | GREATER | GREATEROREQUAL ) a2= plus )*
            	do 
            	{
            	    int alt46 = 2;
            	    int LA46_0 = input.LA(1);

            	    if ( ((LA46_0 >= LESS && LA46_0 <= GREATEROREQUAL)) )
            	    {
            	        alt46 = 1;
            	    }


            	    switch (alt46) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:362:3: ( LESS | LESSOREQUAL | GREATER | GREATEROREQUAL ) a2= plus
            			    {
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:362:3: ( LESS | LESSOREQUAL | GREATER | GREATEROREQUAL )
            			    	int alt45 = 4;
            			    	switch ( input.LA(1) ) 
            			    	{
            			    	case LESS:
            			    		{
            			    	    alt45 = 1;
            			    	    }
            			    	    break;
            			    	case LESSOREQUAL:
            			    		{
            			    	    alt45 = 2;
            			    	    }
            			    	    break;
            			    	case GREATER:
            			    		{
            			    	    alt45 = 3;
            			    	    }
            			    	    break;
            			    	case GREATEROREQUAL:
            			    		{
            			    	    alt45 = 4;
            			    	    }
            			    	    break;
            			    		default:
            			    		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    		    NoViableAltException nvae_d45s0 =
            			    		        new NoViableAltException("", 45, 0, input);

            			    		    throw nvae_d45s0;
            			    	}

            			    	switch (alt45) 
            			    	{
            			    	    case 1 :
            			    	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:362:4: LESS
            			    	        {
            			    	        	Match(input,LESS,FOLLOW_LESS_in_compare1807); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	   retval.type =  T.OperationType.Less; 
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:363:2: LESSOREQUAL
            			    	        {
            			    	        	Match(input,LESSOREQUAL,FOLLOW_LESSOREQUAL_in_compare1814); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	  retval.type =  T.OperationType.LessOrEqual;
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 3 :
            			    	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:364:2: GREATER
            			    	        {
            			    	        	Match(input,GREATER,FOLLOW_GREATER_in_compare1821); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	  retval.type =  T.OperationType.Greater; 
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 4 :
            			    	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:365:2: GREATEROREQUAL
            			    	        {
            			    	        	Match(input,GREATEROREQUAL,FOLLOW_GREATEROREQUAL_in_compare1828); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	  retval.type =  T.OperationType.GreaterOrEqual; 
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_plus_in_compare1840);
            			    	a2 = plus();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  retval.e =  new T.BinaryOperation(retval.type, retval.e, ((a2 != null) ? a2.e : default(T.Expression))); retval.e.StartToken = ((a1 != null) ? a1.e : default(T.Expression)).StartToken; retval.e.EndToken = ((a2 != null) ? a2.e : default(T.Expression)).EndToken; 
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop46;
            	    }
            	} while (true);

            	loop46:
            		;	// Stops C# compiler whining that label 'loop46' has no statements


            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "compare"

    public class equality_return : ParserRuleReturnScope
    {
        public T.Expression e;
        public T.OperationType type;
    };

    // $ANTLR start "equality"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:370:1: equality returns [T.Expression e, T.OperationType type] : a1= compare ( ( EQUALS | NOTEQUAL ) a2= compare )* ;
    public pinedl.equality_return equality() // throws RecognitionException [1]
    {   
        pinedl.equality_return retval = new pinedl.equality_return();
        retval.Start = input.LT(1);

        pinedl.compare_return a1 = default(pinedl.compare_return);

        pinedl.compare_return a2 = default(pinedl.compare_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:370:56: (a1= compare ( ( EQUALS | NOTEQUAL ) a2= compare )* )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:371:2: a1= compare ( ( EQUALS | NOTEQUAL ) a2= compare )*
            {
            	PushFollow(FOLLOW_compare_in_equality1860);
            	a1 = compare();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.e =  ((a1 != null) ? a1.e : default(T.Expression));
            	}
            	if ( state.backtracking == 0 ) 
            	{
            	  retval.type =  default(T.OperationType);
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:373:2: ( ( EQUALS | NOTEQUAL ) a2= compare )*
            	do 
            	{
            	    int alt48 = 2;
            	    int LA48_0 = input.LA(1);

            	    if ( ((LA48_0 >= EQUALS && LA48_0 <= NOTEQUAL)) )
            	    {
            	        alt48 = 1;
            	    }


            	    switch (alt48) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:373:3: ( EQUALS | NOTEQUAL ) a2= compare
            			    {
            			    	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:373:3: ( EQUALS | NOTEQUAL )
            			    	int alt47 = 2;
            			    	int LA47_0 = input.LA(1);

            			    	if ( (LA47_0 == EQUALS) )
            			    	{
            			    	    alt47 = 1;
            			    	}
            			    	else if ( (LA47_0 == NOTEQUAL) )
            			    	{
            			    	    alt47 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d47s0 =
            			    	        new NoViableAltException("", 47, 0, input);

            			    	    throw nvae_d47s0;
            			    	}
            			    	switch (alt47) 
            			    	{
            			    	    case 1 :
            			    	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:373:4: EQUALS
            			    	        {
            			    	        	Match(input,EQUALS,FOLLOW_EQUALS_in_equality1870); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	   retval.type =  T.OperationType.Equal; 
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:373:48: NOTEQUAL
            			    	        {
            			    	        	Match(input,NOTEQUAL,FOLLOW_NOTEQUAL_in_equality1876); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	  retval.type =  T.OperationType.NotEqual; 
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_compare_in_equality1884);
            			    	a2 = compare();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  retval.e =  new T.BinaryOperation(retval.type, retval.e, ((a2 != null) ? a2.e : default(T.Expression))); retval.e.StartToken = ((a1 != null) ? a1.e : default(T.Expression)).StartToken; retval.e.EndToken = ((a2 != null) ? a2.e : default(T.Expression)).EndToken; 
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop48;
            	    }
            	} while (true);

            	loop48:
            		;	// Stops C# compiler whining that label 'loop48' has no statements


            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "equality"


    // $ANTLR start "logicaland"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:379:1: logicaland returns [T.Expression e] : a1= equality ( LOGICALAND a2= equality )* ;
    public T.Expression logicaland() // throws RecognitionException [1]
    {   
        T.Expression e = default(T.Expression);

        pinedl.equality_return a1 = default(pinedl.equality_return);

        pinedl.equality_return a2 = default(pinedl.equality_return);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:379:36: (a1= equality ( LOGICALAND a2= equality )* )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:380:2: a1= equality ( LOGICALAND a2= equality )*
            {
            	PushFollow(FOLLOW_equality_in_logicaland1907);
            	a1 = equality();
            	state.followingStackPointer--;
            	if (state.failed) return e;
            	if ( state.backtracking == 0 ) 
            	{
            	  e =  ((a1 != null) ? a1.e : default(T.Expression)); 
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:381:2: ( LOGICALAND a2= equality )*
            	do 
            	{
            	    int alt49 = 2;
            	    int LA49_0 = input.LA(1);

            	    if ( (LA49_0 == LOGICALAND) )
            	    {
            	        alt49 = 1;
            	    }


            	    switch (alt49) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:381:3: LOGICALAND a2= equality
            			    {
            			    	Match(input,LOGICALAND,FOLLOW_LOGICALAND_in_logicaland1915); if (state.failed) return e;
            			    	PushFollow(FOLLOW_equality_in_logicaland1919);
            			    	a2 = equality();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return e;
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  e =  new T.BinaryOperation(T.OperationType.LogicalAnd, e, ((a2 != null) ? a2.e : default(T.Expression))); e.StartToken = ((a1 != null) ? a1.e : default(T.Expression)).StartToken; e.EndToken = ((a2 != null) ? a2.e : default(T.Expression)).EndToken; 
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop49;
            	    }
            	} while (true);

            	loop49:
            		;	// Stops C# compiler whining that label 'loop49' has no statements


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return e;
    }
    // $ANTLR end "logicaland"


    // $ANTLR start "logicalor"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:383:1: logicalor returns [T.Expression e] : a1= logicaland ( LOGICALOR a2= logicaland )* ;
    public T.Expression logicalor() // throws RecognitionException [1]
    {   
        T.Expression e = default(T.Expression);

        T.Expression a1 = default(T.Expression);

        T.Expression a2 = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:383:35: (a1= logicaland ( LOGICALOR a2= logicaland )* )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:384:2: a1= logicaland ( LOGICALOR a2= logicaland )*
            {
            	PushFollow(FOLLOW_logicaland_in_logicalor1937);
            	a1 = logicaland();
            	state.followingStackPointer--;
            	if (state.failed) return e;
            	if ( state.backtracking == 0 ) 
            	{
            	  e =  a1; 
            	}
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:385:2: ( LOGICALOR a2= logicaland )*
            	do 
            	{
            	    int alt50 = 2;
            	    int LA50_0 = input.LA(1);

            	    if ( (LA50_0 == LOGICALOR) )
            	    {
            	        alt50 = 1;
            	    }


            	    switch (alt50) 
            		{
            			case 1 :
            			    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:385:3: LOGICALOR a2= logicaland
            			    {
            			    	Match(input,LOGICALOR,FOLLOW_LOGICALOR_in_logicalor1943); if (state.failed) return e;
            			    	PushFollow(FOLLOW_logicaland_in_logicalor1947);
            			    	a2 = logicaland();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return e;
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  e =  new T.BinaryOperation(T.OperationType.LogicalOr, e, a2); e.StartToken = a1.StartToken; e.EndToken = a2.EndToken; 
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop50;
            	    }
            	} while (true);

            	loop50:
            		;	// Stops C# compiler whining that label 'loop50' has no statements


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return e;
    }
    // $ANTLR end "logicalor"


    // $ANTLR start "expression"
    // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:387:1: expression returns [T.Expression e] : (c= logicalor ) ;
    public T.Expression expression() // throws RecognitionException [1]
    {   
        T.Expression e = default(T.Expression);

        T.Expression c = default(T.Expression);


        try 
    	{
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:388:2: ( (c= logicalor ) )
            // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:388:4: (c= logicalor )
            {
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:388:4: (c= logicalor )
            	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:388:5: c= logicalor
            	{
            		PushFollow(FOLLOW_logicalor_in_expression1967);
            		c = logicalor();
            		state.followingStackPointer--;
            		if (state.failed) return e;
            		if ( state.backtracking == 0 ) 
            		{
            		  e = c;
            		}

            	}


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return e;
    }
    // $ANTLR end "expression"

    // $ANTLR start "synpred1_pinedl"
    public void synpred1_pinedl_fragment() {
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:133:2: ( RETURN ELLIPSIS )
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:133:3: RETURN ELLIPSIS
        {
        	Match(input,RETURN,FOLLOW_RETURN_in_synpred1_pinedl470); if (state.failed) return ;
        	Match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_synpred1_pinedl472); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred1_pinedl"

    // $ANTLR start "synpred2_pinedl"
    public void synpred2_pinedl_fragment() {
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:134:4: ( ( WORD COLON )? DO )
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:134:5: ( WORD COLON )? DO
        {
        	// /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:134:5: ( WORD COLON )?
        	int alt51 = 2;
        	int LA51_0 = input.LA(1);

        	if ( (LA51_0 == WORD) )
        	{
        	    alt51 = 1;
        	}
        	switch (alt51) 
        	{
        	    case 1 :
        	        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:134:6: WORD COLON
        	        {
        	        	Match(input,WORD,FOLLOW_WORD_in_synpred2_pinedl486); if (state.failed) return ;
        	        	Match(input,COLON,FOLLOW_COLON_in_synpred2_pinedl488); if (state.failed) return ;

        	        }
        	        break;

        	}

        	Match(input,DO,FOLLOW_DO_in_synpred2_pinedl492); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred2_pinedl"

    // $ANTLR start "synpred3_pinedl"
    public void synpred3_pinedl_fragment() {
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:136:4: ( assignmentrightlist )
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:136:5: assignmentrightlist
        {
        	PushFollow(FOLLOW_assignmentrightlist_in_synpred3_pinedl515);
        	assignmentrightlist();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred3_pinedl"

    // $ANTLR start "synpred4_pinedl"
    public void synpred4_pinedl_fragment() {
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:172:3: ( ELSE )
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:172:4: ELSE
        {
        	Match(input,ELSE,FOLLOW_ELSE_in_synpred4_pinedl753); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred4_pinedl"

    // $ANTLR start "synpred5_pinedl"
    public void synpred5_pinedl_fragment() {
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:232:2: ( assignmentrightlist )
        // /home/luis/Documents/Programação/pinedl/Trunk/Pine.Parser/pinedl.g:232:3: assignmentrightlist
        {
        	PushFollow(FOLLOW_assignmentrightlist_in_synpred5_pinedl1171);
        	assignmentrightlist();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred5_pinedl"

    // Delegated rules

   	public bool synpred1_pinedl() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred1_pinedl_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred5_pinedl() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred5_pinedl_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred2_pinedl() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred2_pinedl_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred3_pinedl() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred3_pinedl_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred4_pinedl() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred4_pinedl_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}


   	protected DFA12 dfa12;
   	protected DFA25 dfa25;
	private void InitializeCyclicDFAs()
	{
    	this.dfa12 = new DFA12(this);
    	this.dfa25 = new DFA25(this);
	    this.dfa12.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA12_SpecialStateTransition);
	    this.dfa25.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA25_SpecialStateTransition);
	}

    const string DFA12_eotS =
        "\x1e\uffff";
    const string DFA12_eofS =
        "\x1e\uffff";
    const string DFA12_minS =
        "\x01\x04\x02\x00\x01\uffff\x12\x00\x08\uffff";
    const string DFA12_maxS =
        "\x01\x2b\x02\x00\x01\uffff\x12\x00\x08\uffff";
    const string DFA12_acceptS =
        "\x03\uffff\x01\x02\x12\uffff\x01\x06\x01\uffff\x01\x07\x01\x08\x01"+
        "\x01\x01\x03\x01\x04\x01\x05";
    const string DFA12_specialS =
        "\x01\x00\x01\x01\x01\x02\x01\uffff\x01\x03\x01\x04\x01\x05\x01\x06"+
        "\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\x0e"+
        "\x01\x0f\x01\x10\x01\x11\x01\x12\x01\x13\x01\x14\x08\uffff}>";
    static readonly string[] DFA12_transitionS = {
            "\x01\x0d\x01\x02\x01\x0f\x02\uffff\x02\x16\x01\x05\x01\x04\x06"+
            "\uffff\x01\x01\x01\x18\x01\x19\x03\uffff\x01\x03\x01\uffff\x01"+
            "\x0c\x02\uffff\x01\x0e\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a"+
            "\x01\x0b\x01\uffff\x01\x10\x01\x11\x01\x12\x01\x13\x01\x14\x01"+
            "\x15",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA12_eot = DFA.UnpackEncodedString(DFA12_eotS);
    static readonly short[] DFA12_eof = DFA.UnpackEncodedString(DFA12_eofS);
    static readonly char[] DFA12_min = DFA.UnpackEncodedStringToUnsignedChars(DFA12_minS);
    static readonly char[] DFA12_max = DFA.UnpackEncodedStringToUnsignedChars(DFA12_maxS);
    static readonly short[] DFA12_accept = DFA.UnpackEncodedString(DFA12_acceptS);
    static readonly short[] DFA12_special = DFA.UnpackEncodedString(DFA12_specialS);
    static readonly short[][] DFA12_transition = DFA.UnpackEncodedStringArray(DFA12_transitionS);

    protected class DFA12 : DFA
    {
        public DFA12(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 12;
            this.eot = DFA12_eot;
            this.eof = DFA12_eof;
            this.min = DFA12_min;
            this.max = DFA12_max;
            this.accept = DFA12_accept;
            this.special = DFA12_special;
            this.transition = DFA12_transition;

        }

        override public string Description
        {
            get { return "132:1: semicolonstmt returns [T.Statement stmt] : ( ( RETURN ELLIPSIS )=>r2= returnellipsisstmt | ( ( WORD COLON )? DO )=>dow= dowhilestmt | r= returnstmt | ( assignmentrightlist )=>a= assignmentrightlist | e= expressionstmt | d= declarationstmt | b= breakstmt | c= continuestmt );"; }
        }

    }


    protected internal int DFA12_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA12_0 = input.LA(1);

                   	 
                   	int index12_0 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (LA12_0 == RETURN) ) { s = 1; }

                   	else if ( (LA12_0 == WORD) ) { s = 2; }

                   	else if ( (LA12_0 == DO) && (synpred2_pinedl()) ) { s = 3; }

                   	else if ( (LA12_0 == STRINGCONST) ) { s = 4; }

                   	else if ( (LA12_0 == NUMBER) ) { s = 5; }

                   	else if ( (LA12_0 == CHARCONST) ) { s = 6; }

                   	else if ( (LA12_0 == TRUE) ) { s = 7; }

                   	else if ( (LA12_0 == FALSE) ) { s = 8; }

                   	else if ( (LA12_0 == NULL) ) { s = 9; }

                   	else if ( (LA12_0 == THIS) ) { s = 10; }

                   	else if ( (LA12_0 == CALLEE) ) { s = 11; }

                   	else if ( (LA12_0 == LARRAY) ) { s = 12; }

                   	else if ( (LA12_0 == FUNCTION) ) { s = 13; }

                   	else if ( (LA12_0 == NUMBERKEYWORD) ) { s = 14; }

                   	else if ( (LA12_0 == LPAREN) ) { s = 15; }

                   	else if ( (LA12_0 == INCREMENT) ) { s = 16; }

                   	else if ( (LA12_0 == DECREMENT) ) { s = 17; }

                   	else if ( (LA12_0 == PLUS) ) { s = 18; }

                   	else if ( (LA12_0 == MINUS) ) { s = 19; }

                   	else if ( (LA12_0 == BITNOT) ) { s = 20; }

                   	else if ( (LA12_0 == LOGNOT) ) { s = 21; }

                   	else if ( ((LA12_0 >= VAR && LA12_0 <= CONST)) ) { s = 22; }

                   	else if ( (LA12_0 == BREAK) ) { s = 24; }

                   	else if ( (LA12_0 == CONTINUE) ) { s = 25; }

                   	 
                   	input.Seek(index12_0);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA12_1 = input.LA(1);

                   	 
                   	int index12_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred1_pinedl()) ) { s = 26; }

                   	else if ( (true) ) { s = 27; }

                   	 
                   	input.Seek(index12_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA12_2 = input.LA(1);

                   	 
                   	int index12_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred2_pinedl()) ) { s = 3; }

                   	else if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA12_4 = input.LA(1);

                   	 
                   	int index12_4 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_4);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA12_5 = input.LA(1);

                   	 
                   	int index12_5 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_5);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA12_6 = input.LA(1);

                   	 
                   	int index12_6 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_6);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 6 : 
                   	int LA12_7 = input.LA(1);

                   	 
                   	int index12_7 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_7);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 7 : 
                   	int LA12_8 = input.LA(1);

                   	 
                   	int index12_8 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_8);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 8 : 
                   	int LA12_9 = input.LA(1);

                   	 
                   	int index12_9 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_9);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 9 : 
                   	int LA12_10 = input.LA(1);

                   	 
                   	int index12_10 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_10);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 10 : 
                   	int LA12_11 = input.LA(1);

                   	 
                   	int index12_11 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_11);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 11 : 
                   	int LA12_12 = input.LA(1);

                   	 
                   	int index12_12 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_12);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 12 : 
                   	int LA12_13 = input.LA(1);

                   	 
                   	int index12_13 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_13);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 13 : 
                   	int LA12_14 = input.LA(1);

                   	 
                   	int index12_14 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_14);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 14 : 
                   	int LA12_15 = input.LA(1);

                   	 
                   	int index12_15 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_15);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 15 : 
                   	int LA12_16 = input.LA(1);

                   	 
                   	int index12_16 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_16);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 16 : 
                   	int LA12_17 = input.LA(1);

                   	 
                   	int index12_17 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_17);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 17 : 
                   	int LA12_18 = input.LA(1);

                   	 
                   	int index12_18 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_18);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 18 : 
                   	int LA12_19 = input.LA(1);

                   	 
                   	int index12_19 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_19);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 19 : 
                   	int LA12_20 = input.LA(1);

                   	 
                   	int index12_20 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_20);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 20 : 
                   	int LA12_21 = input.LA(1);

                   	 
                   	int index12_21 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred3_pinedl()) ) { s = 28; }

                   	else if ( (true) ) { s = 29; }

                   	 
                   	input.Seek(index12_21);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 12, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA25_eotS =
        "\x18\uffff";
    const string DFA25_eofS =
        "\x01\x14\x17\uffff";
    const string DFA25_minS =
        "\x01\x04\x13\x00\x04\uffff";
    const string DFA25_maxS =
        "\x01\x2b\x13\x00\x04\uffff";
    const string DFA25_acceptS =
        "\x14\uffff\x01\x02\x02\uffff\x01\x01";
    const string DFA25_specialS =
        "\x01\uffff\x01\x00\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\x06"+
        "\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\x0e"+
        "\x01\x0f\x01\x10\x01\x11\x01\x12\x04\uffff}>";
    static readonly string[] DFA25_transitionS = {
            "\x01\x0b\x01\x01\x01\x0d\x01\x14\x03\uffff\x01\x03\x01\x02\x03"+
            "\uffff\x01\x14\x0a\uffff\x01\x0a\x02\uffff\x01\x0c\x01\x04\x01"+
            "\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\uffff\x01\x0e\x01\x0f"+
            "\x01\x10\x01\x11\x01\x12\x01\x13",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA25_eot = DFA.UnpackEncodedString(DFA25_eotS);
    static readonly short[] DFA25_eof = DFA.UnpackEncodedString(DFA25_eofS);
    static readonly char[] DFA25_min = DFA.UnpackEncodedStringToUnsignedChars(DFA25_minS);
    static readonly char[] DFA25_max = DFA.UnpackEncodedStringToUnsignedChars(DFA25_maxS);
    static readonly short[] DFA25_accept = DFA.UnpackEncodedString(DFA25_acceptS);
    static readonly short[] DFA25_special = DFA.UnpackEncodedString(DFA25_specialS);
    static readonly short[][] DFA25_transition = DFA.UnpackEncodedStringArray(DFA25_transitionS);

    protected class DFA25 : DFA
    {
        public DFA25(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 25;
            this.eot = DFA25_eot;
            this.eof = DFA25_eof;
            this.min = DFA25_min;
            this.max = DFA25_max;
            this.accept = DFA25_accept;
            this.special = DFA25_special;
            this.transition = DFA25_transition;

        }

        override public string Description
        {
            get { return "231:1: rightlist returns [T.RightList r] : ( ( assignmentrightlist )=>arl= assignmentrightlist | crl= constantrightlist );"; }
        }

    }


    protected internal int DFA25_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA25_1 = input.LA(1);

                   	 
                   	int index25_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA25_2 = input.LA(1);

                   	 
                   	int index25_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA25_3 = input.LA(1);

                   	 
                   	int index25_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_3);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA25_4 = input.LA(1);

                   	 
                   	int index25_4 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_4);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA25_5 = input.LA(1);

                   	 
                   	int index25_5 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_5);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA25_6 = input.LA(1);

                   	 
                   	int index25_6 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_6);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 6 : 
                   	int LA25_7 = input.LA(1);

                   	 
                   	int index25_7 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_7);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 7 : 
                   	int LA25_8 = input.LA(1);

                   	 
                   	int index25_8 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_8);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 8 : 
                   	int LA25_9 = input.LA(1);

                   	 
                   	int index25_9 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_9);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 9 : 
                   	int LA25_10 = input.LA(1);

                   	 
                   	int index25_10 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_10);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 10 : 
                   	int LA25_11 = input.LA(1);

                   	 
                   	int index25_11 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_11);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 11 : 
                   	int LA25_12 = input.LA(1);

                   	 
                   	int index25_12 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_12);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 12 : 
                   	int LA25_13 = input.LA(1);

                   	 
                   	int index25_13 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_13);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 13 : 
                   	int LA25_14 = input.LA(1);

                   	 
                   	int index25_14 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_14);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 14 : 
                   	int LA25_15 = input.LA(1);

                   	 
                   	int index25_15 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_15);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 15 : 
                   	int LA25_16 = input.LA(1);

                   	 
                   	int index25_16 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_16);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 16 : 
                   	int LA25_17 = input.LA(1);

                   	 
                   	int index25_17 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_17);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 17 : 
                   	int LA25_18 = input.LA(1);

                   	 
                   	int index25_18 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_18);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 18 : 
                   	int LA25_19 = input.LA(1);

                   	 
                   	int index25_19 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_pinedl()) ) { s = 23; }

                   	else if ( (true) ) { s = 20; }

                   	 
                   	input.Seek(index25_19);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 25, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
 

    public static readonly BitSet FOLLOW_docfunctiondecl_in_document77 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_EOF_in_document83 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FUNCTION_in_docfunctiondecl101 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_WORD_in_docfunctiondecl105 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_LPAREN_in_docfunctiondecl110 = new BitSet(new ulong[]{0x0000000000001EA0UL});
    public static readonly BitSet FOLLOW_arglist_in_docfunctiondecl114 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_RPAREN_in_docfunctiondecl118 = new BitSet(new ulong[]{0x00000FDFCF7B1E70UL});
    public static readonly BitSet FOLLOW_statement_in_docfunctiondecl123 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ordinary_argument_in_arglist157 = new BitSet(new ulong[]{0x0000000000000102UL});
    public static readonly BitSet FOLLOW_COMMA_in_arglist167 = new BitSet(new ulong[]{0x0000000000001E20UL});
    public static readonly BitSet FOLLOW_ordinary_argument_in_arglist176 = new BitSet(new ulong[]{0x0000000000000102UL});
    public static readonly BitSet FOLLOW_COMMA_in_arglist193 = new BitSet(new ulong[]{0x0000000000000620UL});
    public static readonly BitSet FOLLOW_vararg_argument_in_arglist197 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_vararg_argument_in_arglist220 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_VAR_in_ordinary_argument249 = new BitSet(new ulong[]{0x0000000000001820UL});
    public static readonly BitSet FOLLOW_CONST_in_ordinary_argument255 = new BitSet(new ulong[]{0x0000000000001820UL});
    public static readonly BitSet FOLLOW_NUMBER_in_ordinary_argument266 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_WORD_in_ordinary_argument276 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_STRINGCONST_in_ordinary_argument286 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_COLON_in_ordinary_argument292 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_WORD_in_ordinary_argument302 = new BitSet(new ulong[]{0x0000000000004002UL});
    public static readonly BitSet FOLLOW_EQUAL_in_ordinary_argument308 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_ordinary_argument312 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_VAR_in_vararg_argument341 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CONST_in_vararg_argument347 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_WORD_in_vararg_argument359 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_ELLIPSIS_in_vararg_argument366 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_statement385 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unitstmt_in_statement395 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ifstmt_in_statement404 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_whilestmt_in_statement413 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_forstmt_in_statement422 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_semicolonstmt_in_unitstmt441 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_SEMICOLON_in_unitstmt445 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_SEMICOLON_in_unitstmt453 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_returnellipsisstmt_in_semicolonstmt477 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_dowhilestmt_in_semicolonstmt498 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_returnstmt_in_semicolonstmt507 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignmentrightlist_in_semicolonstmt520 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expressionstmt_in_semicolonstmt529 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_declarationstmt_in_semicolonstmt538 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_breakstmt_in_semicolonstmt547 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_continuestmt_in_semicolonstmt556 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_expressionstmt578 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LBLOCK_in_block598 = new BitSet(new ulong[]{0x00000FDFCF7F1E70UL});
    public static readonly BitSet FOLLOW_statement_in_block603 = new BitSet(new ulong[]{0x00000FDFCF7F1E70UL});
    public static readonly BitSet FOLLOW_RBLOCK_in_block609 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_RETURN_in_returnstmt628 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_rightlist_in_returnstmt632 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_RETURN_in_returnellipsisstmt649 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_ELLIPSIS_in_returnellipsisstmt651 = new BitSet(new ulong[]{0x0000001FC8001870UL});
    public static readonly BitSet FOLLOW_atom_in_returnellipsisstmt655 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_BREAK_in_breakstmt676 = new BitSet(new ulong[]{0x0000000000000022UL});
    public static readonly BitSet FOLLOW_WORD_in_breakstmt681 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CONTINUE_in_continuestmt706 = new BitSet(new ulong[]{0x0000000000000022UL});
    public static readonly BitSet FOLLOW_WORD_in_continuestmt711 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IF_in_ifstmt735 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_LPAREN_in_ifstmt737 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_ifstmt741 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_RPAREN_in_ifstmt743 = new BitSet(new ulong[]{0x00000FDFCF7B1E70UL});
    public static readonly BitSet FOLLOW_statement_in_ifstmt748 = new BitSet(new ulong[]{0x0000000000800002UL});
    public static readonly BitSet FOLLOW_ELSE_in_ifstmt758 = new BitSet(new ulong[]{0x00000FDFCF7B1E70UL});
    public static readonly BitSet FOLLOW_statement_in_ifstmt762 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WORD_in_whilestmt788 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_COLON_in_whilestmt792 = new BitSet(new ulong[]{0x0000000001000000UL});
    public static readonly BitSet FOLLOW_WHILE_in_whilestmt799 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_LPAREN_in_whilestmt801 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_whilestmt805 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_RPAREN_in_whilestmt807 = new BitSet(new ulong[]{0x00000FDFCF7B1E70UL});
    public static readonly BitSet FOLLOW_statement_in_whilestmt812 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WORD_in_dowhilestmt835 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_COLON_in_dowhilestmt839 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_DO_in_dowhilestmt846 = new BitSet(new ulong[]{0x00000FDFCF7B1E70UL});
    public static readonly BitSet FOLLOW_statement_in_dowhilestmt851 = new BitSet(new ulong[]{0x0000000001000000UL});
    public static readonly BitSet FOLLOW_WHILE_in_dowhilestmt854 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_LPAREN_in_dowhilestmt856 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_dowhilestmt860 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_RPAREN_in_dowhilestmt862 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WORD_in_forstmt884 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_COLON_in_forstmt888 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_FOR_in_forstmt898 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_LPAREN_in_forstmt900 = new BitSet(new ulong[]{0x00000FDFCA391E70UL});
    public static readonly BitSet FOLLOW_unitstmt_in_forstmt904 = new BitSet(new ulong[]{0x00000FDFC8011870UL});
    public static readonly BitSet FOLLOW_expression_in_forstmt911 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_SEMICOLON_in_forstmt917 = new BitSet(new ulong[]{0x00000FDFC80018F0UL});
    public static readonly BitSet FOLLOW_expressionstmt_in_forstmt922 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_RPAREN_in_forstmt928 = new BitSet(new ulong[]{0x00000FDFCF7B1E70UL});
    public static readonly BitSet FOLLOW_statement_in_forstmt933 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LARRAY_in_arrayconst950 = new BitSet(new ulong[]{0x00000FDFE8001870UL});
    public static readonly BitSet FOLLOW_expression_in_arrayconst962 = new BitSet(new ulong[]{0x0000000010000000UL});
    public static readonly BitSet FOLLOW_ARRAYKEYVALUE_in_arrayconst964 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_arrayconst968 = new BitSet(new ulong[]{0x0000000020000100UL});
    public static readonly BitSet FOLLOW_COMMA_in_arrayconst975 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_arrayconst979 = new BitSet(new ulong[]{0x0000000010000000UL});
    public static readonly BitSet FOLLOW_ARRAYKEYVALUE_in_arrayconst981 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_arrayconst985 = new BitSet(new ulong[]{0x0000000020000100UL});
    public static readonly BitSet FOLLOW_RARRAY_in_arrayconst997 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NUMBERKEYWORD_in_typeconst1014 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NUMBER_in_constant1033 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_STRINGCONST_in_constant1042 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CHARCONST_in_constant1051 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TRUE_in_constant1060 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FALSE_in_constant1069 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NULL_in_constant1078 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_THIS_in_constant1085 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CALLEE_in_constant1092 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_arrayconst_in_constant1101 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_functiondecl_in_constant1110 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typeconst_in_constant1119 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FUNCTION_in_functiondecl1135 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_LPAREN_in_functiondecl1141 = new BitSet(new ulong[]{0x0000000000001EA0UL});
    public static readonly BitSet FOLLOW_arglist_in_functiondecl1145 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_RPAREN_in_functiondecl1149 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_block_in_functiondecl1154 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignmentrightlist_in_rightlist1178 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_constantrightlist_in_rightlist1189 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_crlargument_in_constantrightlist1210 = new BitSet(new ulong[]{0x0000000000000102UL});
    public static readonly BitSet FOLLOW_COMMA_in_constantrightlist1217 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_crlargument_in_constantrightlist1221 = new BitSet(new ulong[]{0x0000000000000102UL});
    public static readonly BitSet FOLLOW_assignmentlistleftside_in_assignmentrightlist1247 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_EQUAL_in_assignmentrightlist1250 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_rightlist_in_assignmentrightlist1254 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_alsargument_in_assignmentlistleftside1276 = new BitSet(new ulong[]{0x0000000000000102UL});
    public static readonly BitSet FOLLOW_COMMA_in_assignmentlistleftside1283 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_alsargument_in_assignmentlistleftside1287 = new BitSet(new ulong[]{0x0000000000000102UL});
    public static readonly BitSet FOLLOW_WORD_in_alsargument1316 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_STRINGCONST_in_alsargument1322 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_NUMBER_in_alsargument1327 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_COLON_in_alsargument1332 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_alsargument1344 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_VAR_in_declarationlist1366 = new BitSet(new ulong[]{0x0000000000001820UL});
    public static readonly BitSet FOLLOW_CONST_in_declarationlist1370 = new BitSet(new ulong[]{0x0000000000001820UL});
    public static readonly BitSet FOLLOW_WORD_in_declarationlist1380 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_STRINGCONST_in_declarationlist1386 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_NUMBER_in_declarationlist1392 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_COLON_in_declarationlist1397 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_WORD_in_declarationlist1404 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_declarationlist_in_declarationstmt1434 = new BitSet(new ulong[]{0x0000000000004002UL});
    public static readonly BitSet FOLLOW_EQUAL_in_declarationstmt1438 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_rightlist_in_declarationstmt1442 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WORD_in_crlargument1470 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_STRINGCONST_in_crlargument1476 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_NUMBER_in_crlargument1482 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_COLON_in_crlargument1487 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_crlargument1498 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_constant_in_atom1516 = new BitSet(new ulong[]{0x0000002008000042UL});
    public static readonly BitSet FOLLOW_WORD_in_atom1525 = new BitSet(new ulong[]{0x0000002008000042UL});
    public static readonly BitSet FOLLOW_LPAREN_in_atom1534 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_rightlist_in_atom1538 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_RPAREN_in_atom1542 = new BitSet(new ulong[]{0x0000002008000042UL});
    public static readonly BitSet FOLLOW_DOT_in_atom1552 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_WORD_in_atom1556 = new BitSet(new ulong[]{0x0000002008000042UL});
    public static readonly BitSet FOLLOW_LPAREN_in_atom1565 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_rightlist_in_atom1569 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_RPAREN_in_atom1573 = new BitSet(new ulong[]{0x0000002008000042UL});
    public static readonly BitSet FOLLOW_LARRAY_in_atom1582 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_expression_in_atom1586 = new BitSet(new ulong[]{0x0000000020000000UL});
    public static readonly BitSet FOLLOW_RARRAY_in_atom1590 = new BitSet(new ulong[]{0x0000002008000042UL});
    public static readonly BitSet FOLLOW_atom_in_pfix1613 = new BitSet(new ulong[]{0x000000C000000002UL});
    public static readonly BitSet FOLLOW_INCREMENT_in_pfix1619 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DECREMENT_in_pfix1625 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_pfix_in_unary1648 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_INCREMENT_in_unary1660 = new BitSet(new ulong[]{0x0000001FC8001870UL});
    public static readonly BitSet FOLLOW_DECREMENT_in_unary1666 = new BitSet(new ulong[]{0x0000001FC8001870UL});
    public static readonly BitSet FOLLOW_PLUS_in_unary1672 = new BitSet(new ulong[]{0x0000001FC8001870UL});
    public static readonly BitSet FOLLOW_MINUS_in_unary1678 = new BitSet(new ulong[]{0x0000001FC8001870UL});
    public static readonly BitSet FOLLOW_BITNOT_in_unary1684 = new BitSet(new ulong[]{0x0000001FC8001870UL});
    public static readonly BitSet FOLLOW_LOGNOT_in_unary1690 = new BitSet(new ulong[]{0x0000001FC8001870UL});
    public static readonly BitSet FOLLOW_pfix_in_unary1698 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_in_mult1715 = new BitSet(new ulong[]{0x0000100000000002UL});
    public static readonly BitSet FOLLOW_MULT_in_mult1725 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_unary_in_mult1733 = new BitSet(new ulong[]{0x0000100000000002UL});
    public static readonly BitSet FOLLOW_mult_in_plus1753 = new BitSet(new ulong[]{0x0000030000000002UL});
    public static readonly BitSet FOLLOW_PLUS_in_plus1763 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_MINUS_in_plus1769 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_mult_in_plus1777 = new BitSet(new ulong[]{0x0000030000000002UL});
    public static readonly BitSet FOLLOW_plus_in_compare1797 = new BitSet(new ulong[]{0x0001E00000000002UL});
    public static readonly BitSet FOLLOW_LESS_in_compare1807 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_LESSOREQUAL_in_compare1814 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_GREATER_in_compare1821 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_GREATEROREQUAL_in_compare1828 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_plus_in_compare1840 = new BitSet(new ulong[]{0x0001E00000000002UL});
    public static readonly BitSet FOLLOW_compare_in_equality1860 = new BitSet(new ulong[]{0x0006000000000002UL});
    public static readonly BitSet FOLLOW_EQUALS_in_equality1870 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_NOTEQUAL_in_equality1876 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_compare_in_equality1884 = new BitSet(new ulong[]{0x0006000000000002UL});
    public static readonly BitSet FOLLOW_equality_in_logicaland1907 = new BitSet(new ulong[]{0x0008000000000002UL});
    public static readonly BitSet FOLLOW_LOGICALAND_in_logicaland1915 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_equality_in_logicaland1919 = new BitSet(new ulong[]{0x0008000000000002UL});
    public static readonly BitSet FOLLOW_logicaland_in_logicalor1937 = new BitSet(new ulong[]{0x0010000000000002UL});
    public static readonly BitSet FOLLOW_LOGICALOR_in_logicalor1943 = new BitSet(new ulong[]{0x00000FDFC8001870UL});
    public static readonly BitSet FOLLOW_logicaland_in_logicalor1947 = new BitSet(new ulong[]{0x0010000000000002UL});
    public static readonly BitSet FOLLOW_logicalor_in_expression1967 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_RETURN_in_synpred1_pinedl470 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_ELLIPSIS_in_synpred1_pinedl472 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WORD_in_synpred2_pinedl486 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_COLON_in_synpred2_pinedl488 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_DO_in_synpred2_pinedl492 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignmentrightlist_in_synpred3_pinedl515 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ELSE_in_synpred4_pinedl753 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignmentrightlist_in_synpred5_pinedl1171 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}